chef 12.0.0.alpha.1 → 12.0.0.alpha.2

data/spec/unit/provider/service/upstart_service_spec.rb

@@ -161,7 +161,6 @@ describe Chef::Provider::Service::Upstart do
       @provider.load_current_resource
     end
 
-
     it "should track state when the upstart configuration file fails to load" do
       File.should_receive(:exists?).and_return false
       @provider.load_current_resource
@@ -174,19 +173,19 @@ describe Chef::Provider::Service::Upstart do
       end
 
       it "should run the services status command if one has been specified" do
-        @provider.stub(:run_command_with_systems_locale).with({:command => "/bin/chefhasmonkeypants status"}).and_return(0)
+        @provider.stub(:shell_out!).with("/bin/chefhasmonkeypants status").and_return(0)
         @current_resource.should_receive(:running).with(true)
         @provider.load_current_resource
       end
 
       it "should track state when the user-provided status command fails" do
-        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @provider.stub(:shell_out!).and_raise(Errno::ENOENT)
         @provider.load_current_resource
         @provider.instance_variable_get("@command_success").should == false
       end
 
       it "should set running to false if it catches a Chef::Exceptions::Exec when using a status command" do
-        @provider.stub(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_raise(Chef::Exceptions::Exec)
+        @provider.stub(:shell_out!).and_raise(Errno::ENOENT)
         @current_resource.should_receive(:running).with(false)
         @provider.load_current_resource
       end
@@ -202,7 +201,6 @@ describe Chef::Provider::Service::Upstart do
       @provider.load_current_resource.should eql(@current_resource)
     end
 
-
   end
 
   describe "enable and disable service" do
@@ -243,18 +241,18 @@ describe Chef::Provider::Service::Upstart do
 
     it "should call the start command if one is specified" do
       @new_resource.stub(:start_command).and_return("/sbin/rsyslog startyousillysally")
-      @provider.should_receive(:shell_out!).with("/sbin/rsyslog startyousillysally")
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog startyousillysally")
       @provider.start_service()
     end
 
     it "should call '/sbin/start service_name' if no start command is specified" do
-      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
       @provider.start_service()
     end
 
     it "should not call '/sbin/start service_name' if it is already running" do
       @current_resource.stub(:running).and_return(true)
-      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"})
+      @provider.should_not_receive(:shell_out_with_systems_locale!)
       @provider.start_service()
     end
 
@@ -263,58 +261,58 @@ describe Chef::Provider::Service::Upstart do
       @new_resource.parameters({ "OSD_ID" => "2" })
       @provider = Chef::Provider::Service::Upstart.new(@new_resource, @run_context)
       @provider.current_resource = @current_resource
-      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start rsyslog OSD_ID=2"}).and_return(0)
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/start rsyslog OSD_ID=2").and_return(0)
       @provider.start_service()
     end
 
     it "should call the restart command if one is specified" do
       @current_resource.stub(:running).and_return(true)
       @new_resource.stub(:restart_command).and_return("/sbin/rsyslog restartyousillysally")
-      @provider.should_receive(:shell_out!).with("/sbin/rsyslog restartyousillysally")
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog restartyousillysally")
       @provider.restart_service()
     end
 
     it "should call '/sbin/restart service_name' if no restart command is specified" do
       @current_resource.stub(:running).and_return(true)
-      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/restart #{@new_resource.service_name}"}).and_return(0)
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/restart #{@new_resource.service_name}").and_return(0)
       @provider.restart_service()
     end
 
     it "should call '/sbin/start service_name' if restart_service is called for a stopped service" do
       @current_resource.stub(:running).and_return(false)
-      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/start #{@new_resource.service_name}"}).and_return(0)
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/start #{@new_resource.service_name}").and_return(0)
       @provider.restart_service()
     end
 
     it "should call the reload command if one is specified" do
       @current_resource.stub(:running).and_return(true)
       @new_resource.stub(:reload_command).and_return("/sbin/rsyslog reloadyousillysally")
-      @provider.should_receive(:shell_out!).with("/sbin/rsyslog reloadyousillysally")
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog reloadyousillysally")
       @provider.reload_service()
     end
 
     it "should call '/sbin/reload service_name' if no reload command is specified" do
       @current_resource.stub(:running).and_return(true)
-      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/reload #{@new_resource.service_name}"}).and_return(0)
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/reload #{@new_resource.service_name}").and_return(0)
       @provider.reload_service()
     end
 
     it "should call the stop command if one is specified" do
       @current_resource.stub(:running).and_return(true)
       @new_resource.stub(:stop_command).and_return("/sbin/rsyslog stopyousillysally")
-      @provider.should_receive(:shell_out!).with("/sbin/rsyslog stopyousillysally")
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/rsyslog stopyousillysally")
       @provider.stop_service()
     end
 
     it "should call '/sbin/stop service_name' if no stop command is specified" do
       @current_resource.stub(:running).and_return(true)
-      @provider.should_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"}).and_return(0)
+      @provider.should_receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}").and_return(0)
       @provider.stop_service()
     end
 
     it "should not call '/sbin/stop service_name' if it is already stopped" do
       @current_resource.stub(:running).and_return(false)
-      @provider.should_not_receive(:run_command_with_systems_locale).with({:command => "/sbin/stop #{@new_resource.service_name}"})
+      @provider.should_not_receive(:shell_out_with_systems_locale!).with("/sbin/stop #{@new_resource.service_name}")
       @provider.stop_service()
     end
   end

data/spec/unit/provider/subversion_spec.rb

@@ -16,7 +16,6 @@
 # limitations under the License.
 #
 
-
 require 'spec_helper'
 
 describe Chef::Provider::Subversion do
@@ -199,7 +198,7 @@ describe Chef::Provider::Subversion do
   it "runs an export with the --force option" do
     ::File.stub(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.should_receive(:shell_out!).with(command: expected_cmd)
     @provider.run_action(:force_export)
     @resource.should be_updated
   end
@@ -207,7 +206,7 @@ describe Chef::Provider::Subversion do
   it "runs the checkout command for action_checkout" do
     ::File.stub(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn checkout -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.should_receive(:shell_out!).with(command: expected_cmd)
     @provider.run_action(:checkout)
     @resource.should be_updated
   end
@@ -231,7 +230,7 @@ describe Chef::Provider::Subversion do
     @resource.user "whois"
     @resource.group "thisis"
     expected_cmd = "svn checkout -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    @provider.should_receive(:run_command).with(:command => expected_cmd, :user => "whois", :group => "thisis")
+    @provider.should_receive(:shell_out!).with(command: expected_cmd, user: "whois", group: "thisis")
     @provider.run_action(:checkout)
     @resource.should be_updated
   end
@@ -256,7 +255,7 @@ describe Chef::Provider::Subversion do
     @provider.stub(:find_current_revision).and_return("11410")
     @provider.stub(:current_revision_matches_target_revision?).and_return(false)
     expected_cmd = "svn update -q  -r12345 /my/deploy/dir"
-    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.should_receive(:shell_out!).with(command: expected_cmd)
     @provider.run_action(:sync)
     @resource.should be_updated
   end
@@ -273,7 +272,7 @@ describe Chef::Provider::Subversion do
   it "runs the export_command on action_export" do
     ::File.stub(:directory?).with("/my/deploy").and_return(true)
     expected_cmd = "svn export --force -q  -r12345 http://svn.example.org/trunk/ /my/deploy/dir"
-    @provider.should_receive(:run_command).with(:command => expected_cmd)
+    @provider.should_receive(:shell_out!).with(command: expected_cmd)
     @provider.run_action(:export)
     @resource.should be_updated
   end

data/spec/unit/provider/user/dscl_spec.rb

@@ -376,6 +376,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
     let(:user_plist_file) { nil }
 
     before do
+      provider.should_receive(:shell_out).with("dscacheutil '-flushcache'")
       provider.should_receive(:shell_out).with("plutil -convert xml1 -o - /var/db/dslocal/nodes/Default/users/toor.plist") do
         if user_plist_file.nil?
           ShellCmdResult.new('Can not find the file', 'Sorry!!', 1)
@@ -715,7 +716,6 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
       provider.should_receive(:read_user_info)
       provider.should_receive(:dscl_set)
       provider.should_receive(:sleep).with(3)
-      provider.should_receive(:shell_out).with("dscacheutil '-flushcache'")
       provider.should_receive(:save_user_info)
       provider.set_password
     end
@@ -822,6 +822,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
   describe "when the user exists" do
     before do
+      provider.should_receive(:shell_out).with("dscacheutil '-flushcache'")
       provider.should_receive(:shell_out).with("plutil -convert xml1 -o - /var/db/dslocal/nodes/Default/users/toor.plist") do
         ShellCmdResult.new(File.read(File.join(CHEF_SPEC_DATA, "mac_users/10.9.plist.xml")), "", 0)
       end

data/spec/unit/provider/user/windows_spec.rb

@@ -42,6 +42,12 @@ describe Chef::Provider::User::Windows do
     @provider.current_resource = @current_resource
   end
 
+  it "creates a net_user object with the provided username" do
+    @new_resource.username "not-monkey"
+    expect(Chef::Util::Windows::NetUser).to receive(:new).with("not-monkey")
+    @provider = Chef::Provider::User::Windows.new(@new_resource, @run_context)
+  end
+
   describe "when comparing the user's current attributes to the desired attributes" do
     before do
       @new_resource.comment   "Adam Jacob"
@@ -53,6 +59,7 @@ describe Chef::Provider::User::Windows do
 
       @provider.current_resource = @new_resource.clone
     end
+
     describe "and the attributes match" do
       it "doesn't set the comment field to be updated" do
         @provider.set_options.should_not have_key(:full_name)

data/spec/unit/provider/whyrun_safe_ruby_block_spec.rb

@@ -30,14 +30,14 @@ describe Chef::Provider::WhyrunSafeRubyBlock, "initialize" do
   end
 
   it "should call the block and flag the resource as updated" do
-    @provider.run_action(:create)
+    @provider.run_action(:run)
     $evil_global_evil_laugh.should == :mwahahaha
     @new_resource.should be_updated
   end
 
   it "should call the block and flat the resource as updated - even in whyrun" do
     Chef::Config[:why_run] = true
-    @provider.run_action(:create)
+    @provider.run_action(:run)
     $evil_global_evil_laugh.should == :mwahahaha
     @new_resource.should be_updated
     Chef::Config[:why_run] = false

data/spec/unit/resource/mount_spec.rb

@@ -53,6 +53,15 @@ describe Chef::Resource::Mount do
     @resource.device.should eql("/dev/sdb3")
   end
 
+  it "should set fsck_device to '-' by default" do
+    @resource.fsck_device.should eql('-')
+  end
+
+  it "should allow you to set the fsck_device attribute" do
+    @resource.fsck_device "/dev/rdsk/sdb3"
+    @resource.fsck_device.should eql("/dev/rdsk/sdb3")
+  end
+
   it "should allow you to set the fstype attribute" do
     @resource.fstype "nfs"
     @resource.fstype.should eql("nfs")

data/spec/unit/resource_spec.rb

@@ -421,10 +421,6 @@ describe Chef::Resource do
 
   end
 
-  it "supports accessing the node via the @node instance variable [DEPRECATED]" do
-    @resource.instance_variable_get(:@node).inspect.should == @node.inspect
-  end
-
   it "runs an action by finding its provider, loading the current resource and then running the action" do
     pending
   end

data/spec/unit/rest_spec.rb

@@ -540,7 +540,7 @@ describe Chef::REST do
       let(:request_mock) { {} }
 
       let(:http_response) do
-        http_response = Net::HTTPSuccess.new("1.1",200, "it-works")
+        http_response = Net::HTTPSuccess.new("1.1",'200', "it-works")
 
         http_response.stub(:read_body)
         http_response.should_not_receive(:body)

data/spec/unit/run_context_spec.rb

@@ -134,4 +134,19 @@ describe Chef::RunContext do
     end
   end
 
+  describe "handling reboot requests" do
+    let(:expected) do
+      { :reason => "spec tests require a reboot" }
+    end
+
+    it "stores and deletes the reboot request" do
+      @run_context.request_reboot(expected)
+      expect(@run_context.reboot_info).to eq(expected)
+      expect(@run_context.reboot_requested?).to be_true
+
+      @run_context.cancel_reboot
+      expect(@run_context.reboot_info).to eq({})
+      expect(@run_context.reboot_requested?).to be_false
+    end
+  end
 end

data/spec/unit/search/query_spec.rb

@@ -20,80 +20,236 @@ require 'spec_helper'
 require 'chef/search/query'
 
 describe Chef::Search::Query do
-  before(:each) do
-    @rest = double("Chef::REST")
-    Chef::REST.stub(:new).and_return(@rest)
-    @query = Chef::Search::Query.new
-  end
+  let(:rest) { double("Chef::REST") }
+  let(:query) { Chef::Search::Query.new }
 
-  describe "search" do
-    before(:each) do
-      @response = {
+  shared_context "filtered search" do
+    let(:query_string) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000" }
+    let(:server_url) { "https://api.opscode.com/organizations/opscode/nodes" }
+    let(:args) { { filter_key => filter_hash } }
+    let(:filter_hash) {
+      {
+        'env' => [ 'chef_environment' ],
+        'ruby_plat' => [ 'languages', 'ruby', 'platform' ]
+      }
+    }
+    let(:response) {
+      {
         "rows" => [
-          { "id" => "for you" },
-          { "id" => "hip hop" },
-          { "id" => "thought was down by law for you" },
-          { "id" => "kept it hard core for you" },
+          { "url" => "#{server_url}/my-name-is-node",
+            "data" => {
+              "env" => "elysium",
+              "ruby_plat" => "nudibranch"
+            }
+          },
+          { "url" => "#{server_url}/my-name-is-jonas",
+            "data" => {
+              "env" => "hades",
+              "ruby_plat" => "i386-mingw32"
+            }
+          },
+          { "url" => "#{server_url}/my-name-is-flipper",
+            "data" => {
+              "env" => "elysium",
+              "ruby_plat" => "centos"
+            }
+          },
+          { "url" => "#{server_url}/my-name-is-butters",
+            "data" => {
+              "env" => "moon",
+              "ruby_plat" => "solaris2",
+            }
+          }
         ],
         "start" => 0,
         "total" => 4
       }
-      @rest.stub(:get_rest).and_return(@response)
-    end
+    }
+  end
+
+  before(:each) do
+    Chef::REST.stub(:new).and_return(rest)
+    rest.stub(:get_rest).and_return(response)
+  end
+
+  describe "search" do
+    let(:response) { {
+      "rows" => [
+        { "name" => "my-name-is-node",
+          "chef_environment" => "elysium",
+          "platform" => "rhel",
+          "automatic" => {
+            "languages" => {
+              "ruby" => {
+                "platform" => "nudibranch",
+                "version" => "1.9.3",
+                "target" => "ming-the-merciless"
+              }
+            }
+          }
+        },
+        { "name" => "my-name-is-jonas",
+          "chef_environment" => "hades",
+          "platform" => "rhel",
+          "automatic" => {
+            "languages" => {
+              "ruby" => {
+                "platform" => "i386-mingw32",
+                "version" => "1.9.3",
+                "target" => "bilbo"
+              }
+            }
+          }
+        },
+        { "name" => "my-name-is-flipper",
+          "chef_environment" => "elysium",
+          "platform" => "rhel",
+          "automatic" => {
+            "languages" => {
+              "ruby" => {
+                "platform" => "centos",
+                "version" => "2.0.0",
+                "target" => "uno"
+              }
+            }
+          }
+        },
+        { "name" => "my-name-is-butters",
+          "chef_environment" => "moon",
+          "platform" => "rhel",
+          "automatic" => {
+            "languages" => {
+              "ruby" => {
+                "platform" => "solaris2",
+                "version" => "2.1.2",
+                "target" => "random"
+              }
+            }
+          }
+        },
+      ],
+      "start" => 0,
+      "total" => 4
+    } }
 
     it "should accept a type as the first argument" do
-      lambda { @query.search("foo") }.should_not raise_error
-      lambda { @query.search(:foo) }.should_not raise_error
-      lambda { @query.search(Hash.new) }.should raise_error(ArgumentError)
+      lambda { query.search("node") }.should_not raise_error
+      lambda { query.search(:node) }.should_not raise_error
+      lambda { query.search(Hash.new) }.should raise_error(Chef::Exceptions::InvalidSearchQuery, /(Hash)/)
     end
 
     it "should query for every object of a type by default" do
-      @rest.should_receive(:get_rest).with("search/foo?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000").and_return(@response)
-      @query = Chef::Search::Query.new
-      @query.search(:foo)
+      rest.should_receive(:get_rest).with("search/node?q=*:*&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000").and_return(response)
+      query.search(:node)
     end
 
     it "should allow a custom query" do
-      @rest.should_receive(:get_rest).with("search/foo?q=gorilla:dundee&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000").and_return(@response)
-      @query = Chef::Search::Query.new
-      @query.search(:foo, "gorilla:dundee")
+      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=1000").and_return(response)
+      query.search(:node, "platform:rhel")
     end
 
     it "should let you set a sort order" do
-      @rest.should_receive(:get_rest).with("search/foo?q=gorilla:dundee&sort=id%20desc&start=0&rows=1000").and_return(@response)
-      @query = Chef::Search::Query.new
-      @query.search(:foo, "gorilla:dundee", "id desc")
+      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=0&rows=1000").and_return(response)
+      query.search(:node, "platform:rhel", "id desc")
     end
 
     it "should let you set a starting object" do
-      @rest.should_receive(:get_rest).with("search/foo?q=gorilla:dundee&sort=id%20desc&start=2&rows=1000").and_return(@response)
-      @query = Chef::Search::Query.new
-      @query.search(:foo, "gorilla:dundee", "id desc", 2)
+      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=2&rows=1000").and_return(response)
+      query.search(:node, "platform:rhel", "id desc", 2)
     end
 
     it "should let you set how many rows to return" do
-      @rest.should_receive(:get_rest).with("search/foo?q=gorilla:dundee&sort=id%20desc&start=2&rows=40").and_return(@response)
-      @query = Chef::Search::Query.new
-      @query.search(:foo, "gorilla:dundee", "id desc", 2, 40)
+      rest.should_receive(:get_rest).with("search/node?q=platform:rhel&sort=id%20desc&start=2&rows=40").and_return(response)
+      query.search(:node, "platform:rhel", "id desc", 2, 40)
+    end
+
+    it "should throw an exception if you pass to many options" do
+      lambda { query.search(:node, "platform:rhel", "id desc", 2, 40, "wrong") }
+        .should raise_error(Chef::Exceptions::InvalidSearchQuery, "Too many arguments! (4 for <= 3)")
     end
 
     it "should return the raw rows, start, and total if no block is passed" do
-      rows, start, total = @query.search(:foo)
-      rows.should equal(@response["rows"])
-      start.should equal(@response["start"])
-      total.should equal(@response["total"])
+      rows, start, total = query.search(:node)
+      rows.should equal(response["rows"])
+      start.should equal(response["start"])
+      total.should equal(response["total"])
     end
 
     it "should call a block for each object in the response" do
       @call_me = double("blocky")
-      @response["rows"].each { |r| @call_me.should_receive(:do).with(r) }
-      @query.search(:foo) { |r| @call_me.do(r) }
+      response["rows"].each { |r| @call_me.should_receive(:do).with(r) }
+      query.search(:node) { |r| @call_me.do(r) }
     end
 
     it "should page through the responses" do
       @call_me = double("blocky")
-      @response["rows"].each { |r| @call_me.should_receive(:do).with(r) }
-      @query.search(:foo, "*:*", nil, 0, 1) { |r| @call_me.do(r) }
+      response["rows"].each { |r| @call_me.should_receive(:do).with(r) }
+      query.search(:node, "*:*", nil, 0, 1) { |r| @call_me.do(r) }
+    end
+
+    context "when :filter_result is provided as a result" do
+      include_context "filtered search" do
+        let(:filter_key) { :filter_result }
+
+        before(:each) do
+          rest.should_receive(:post_rest).with(query_string, args[filter_key]).and_return(response)
+        end
+
+        it "should return start" do
+          start = query.search(:node, "platform:rhel", args)[1]
+          start.should == response['start']
+        end
+
+        it "should return total" do
+          total = query.search(:node, "platform:rhel", args)[2]
+          total.should == response['total']
+        end
+
+        it "should return rows with the filter applied" do
+          results = query.search(:node, "platform:rhel", args)[0]
+
+          results.each_with_index do |result, idx|
+            expected = response["rows"][idx]
+
+            result.should have_key("url")
+            result["url"].should == expected["url"]
+
+            result.should have_key("data")
+            filter_hash.keys.each do |filter_key|
+              result["data"].should have_key(filter_key)
+              result["data"][filter_key].should == expected["data"][filter_key]
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  describe "#partial_search" do
+    include_context "filtered search" do
+      let(:filter_key) { :keys }
+
+      it "should emit a deprecation warning" do
+        # partial_search calls search, so we'll stub search to return empty
+        query.stub(:search).and_return( [ [], 0, 0 ] )
+        Chef::Log.should_receive(:warn).with("DEPRECATED: The 'partial_search' api is deprecated, please use the search api with 'filter_result'")
+        query.partial_search(:node, "platform:rhel", args)
+      end
+
+      it "should return an array of filtered hashes" do
+        rest.should_receive(:post_rest).with(query_string, args[filter_key]).and_return(response)
+        results = query.partial_search(:node, "platform:rhel", args)
+
+        results.each_with_index do |result, idx|
+          expected = response["rows"][idx]
+
+          filter_hash.keys.each do |filter_key|
+            result.should have_key(filter_key)
+            result[filter_key].should == expected["data"][filter_key]
+          end
+        end
+      end
     end
   end
 end