     alias Yodado.Definition.All, as: All
 
     test "is true if all conditions match" do
-      definition = All[conditions: [true, true]]
+      definition = All[definitions: [true, true]]
       assert Rule.matches?(definition, [])
     end
 
     test "is false unless all conditions match" do
-      definition = All[conditions: [true, false]]
+      definition = All[definitions: [true, false]]
       assert !Rule.matches?(definition, [])
     end
 
     test "it passes the state through to child conditions" do
-      definition = All[conditions: [
+      definition = All[definitions: [
         fn(state) -> state[:foo] == 1 end,
         fn(state) -> state[:bar] == 2 end
       ]]

    """
    actual_definition = json |> JSEX.decode!(labels: :atom) |> Yodado.Definition.from_json
    expected_definition = 
      Yodado.Definition.Any[conditions: [
        Yodado.Definition.All[conditions: [
          Yodado.Definition.IncludedIn[param_name: "username", value: ["madlep", "gstamp"]],
          Yodado.Definition.IncludedIn[param_name: "host", value: ["themeforest.net", "codecanyon.net"]]
        ]],
        Yodado.Definition.Is[param_name: "session_on"],
        Yodado.Definition.IncludedIn[param_name: "role", value: ["developer"]]
      ]]

    assert actual_definition == expected_definition

    alias Yodado.Definition.Is, as: Is

    test "is true if the value of the param in the state equals the value" do
      definition = Is[actual_state_param_name: "session_on", allowed_value: "yes"]
      assert Rule.matches?(definition, [{"session_on", "yes"}]) 
    end

    test "is false if the value of the param in the state does not equals the value" do
      definition = Is[actual_state_param_name: "session_on", allowed_value: "yes"]
      assert !Rule.matches?(definition, [{"session_on", "HAHA"}]) 
    end

    test "it generates JSON" do
      definition = Is[actual_state_param_name: "session_on", allowed_value: "yes"]
      expected_json = "{\"operand\":\"is\",\"param_name\":\"session_on\",\"value\":\"yes\"}"
      actual_json = Rule.json(definition) |> JSEX.encode!
      assert actual_json == expected_json
