helix 0.0.2.8.pre → 0.0.2.9.pre

data/spec/config_spec.rb

@@ -53,7 +53,8 @@ describe Helix::Config do
     let(:meth)      { :load }
     let(:mock_obj)  { mock(klass, proxy: :stubbed_proxy) }
     let(:mock_file) { mock(File)  }
-    let(:mock_cred) { mock(Hash, symbolize_keys: :symbolized_creds) }
+    let(:mock_cred) { {key1: 'value1', 'key2' => 'value2'} }
+    let(:symbolized_cred) { {key1: 'value1', key2: 'value2'} }
     before(:each) do
       klass.stub(:instance) { mock_obj  }
       File.stub(:open)      { mock_file }
@@ -78,10 +79,10 @@ describe Helix::Config do
         YAML.should_receive(:load).with(mock_file) { mock_cred }
         klass.send(meth)
       end
-      it "should set @credentials to cred.symbolize_keys" do
+      it "should set @credentials to cred with symbol keys" do
         File.stub(:open).with(klass::DEFAULT_FILENAME) { mock_file }
         YAML.stub(:load).with(mock_file) { mock_cred }
-        mock_obj.should_receive(:instance_variable_set).with(:@credentials, mock_cred.symbolize_keys)
+        mock_obj.should_receive(:instance_variable_set).with(:@credentials, symbolized_cred)
         klass.send(meth)
       end
       it "should set the proxy" do
@@ -111,10 +112,10 @@ describe Helix::Config do
         YAML.should_receive(:load).with(mock_file) { mock_cred }
         klass.send(meth, yaml_arg)
       end
-      it "should set @credentials to cred.symbolize_keys" do
+      it "should set @credentials to cred with symbol keys" do
         File.stub(:open).with(klass::DEFAULT_FILENAME) { mock_file }
         YAML.stub(:load).with(mock_file) { mock_cred }
-        mock_obj.should_receive(:instance_variable_set).with(:@credentials, mock_cred.symbolize_keys)
+        mock_obj.should_receive(:instance_variable_set).with(:@credentials, symbolized_cred)
         klass.send(meth, yaml_arg)
       end
       it "should return the instance" do

data/spec/media_spec.rb

@@ -3,191 +3,211 @@ require 'helix'
 
 describe Helix::Media do
 
-  let(:klass) { Helix::Media }
-
-  subject { klass }
-
-  mods = [ Helix::RESTful, Helix::Uploadable ]
-  mods.each { |mod| its(:ancestors) { should include(mod) } }
-
-  describe ".create" do
-    let(:meth)        { :create }
-    let(:mock_config) { mock(Helix::Config) }
-    subject           { klass.method(meth) }
-    its(:arity)       { should eq(-1) }
-    let(:klass_sym)   { :klass }
-    let(:resp_value)  { { klass_sym.to_s => { attribute: :value } } }
-    let(:resp_json)   { "JSON" }
-    let(:params)      { { signature: "some_sig" } }
-    let(:expected)    { { attributes: { attribute: :value }, config: mock_config } }
-    context "when a Helix:Config instance is absent" do
-      before(:each) do Helix::Config.stub(:instance) { nil } end
-      it "should raise a NoConfigurationLoaded exception" do
-        lambda { klass.send(meth) }.should raise_error(Helix::NoConfigurationLoaded)
-      end
+  shared_examples_for "builds URL for update" do
+    it "should build_url(content_type: :xml, guid: guid, resource_label: plural_resource_label)" do
+      mock_config.should_receive(:build_url).with(content_type: :xml, guid: :the_guid, resource_label: :the_resource_label)
+      RestClient.stub(:put)
+      obj.send(meth)
     end
-    context "when a Helix:Config instance is present" do
-      before(:each) do
-        klass.stub(:plural_resource_label) { :klasses }
-        klass.stub(:resource_label_sym)    { klass_sym }
-        mock_config.stub(:build_url).with(content_type: :xml, resource_label: :klasses) { :url }
-        mock_config.stub(:signature).with(:update) { "some_sig" }
-        Helix::Config.stub(:instance) { mock_config }
-      end
-      it "should get an ingest signature" do
-        mock_config.should_receive(:build_url).with(resource_label: :klasses,
-                                                    content_type:   :xml)
-        RestClient.stub(:post).with(:url, params) { resp_json }
-        Hash.should_receive(:from_xml).with(resp_json) { resp_value }
-        klass.stub(:new).with(expected)
-        mock_config.should_receive(:signature).with(:update) { "some_sig" }
-        klass.send(meth)
-      end
-      it "should do an HTTP post call, parse response and call new" do
-        mock_config.should_receive(:build_url).with(resource_label: :klasses,
-                                                    content_type:   :xml)
-        RestClient.should_receive(:post).with(:url, params) { resp_json }
-        Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
-        klass.should_receive(:new).with(expected)
-        klass.send(meth)
-      end
+    it "should get an update signature" do
+      mock_config.stub(:build_url)
+      RestClient.stub(:put)
+      mock_config.should_receive(:signature).with(:update) { 'some_sig' }
+      obj.send(meth)
     end
   end
 
-  describe ".find" do
-    let(:meth)        { :find }
-    let(:mock_config) { mock(Helix::Config) }
-    let(:mock_obj)    { mock(klass, :load => :output_of_load) }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(1) }
-    context "when a Helix:Config instance is absent" do
-      before(:each) do Helix::Config.stub(:instance) { nil } end
-      context "and given a guid" do
-        let(:guid_name)  { :the_guid_name }
-        let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
+  klasses = [ Helix::Album, Helix::Image, Helix::Track, Helix::Video ]
+  klasses.each do |klass|
+
+    subject { klass }
+
+    mods = [ Helix::RESTful, Helix::Uploadable ]
+    mods.each { |mod| its(:ancestors) { should include(mod) } }
+
+    describe ".create" do
+      let(:meth)        { :create }
+      let(:mock_config) { mock(Helix::Config) }
+      subject           { klass.method(meth) }
+      its(:arity)       { should eq(-1) }
+      let(:klass_sym)   { :klass }
+      let(:resp_value)  { { klass_sym.to_s => { attribute: :value } } }
+      let(:resp_json)   { "JSON" }
+      let(:params)      { { signature: "some_sig" } }
+      let(:expected)    { { attributes: { attribute: :value }, config: mock_config } }
+      context "when a Helix:Config instance is absent" do
+        before(:each) do Helix::Config.stub(:instance) { nil } end
+        it "should raise a NoConfigurationLoaded exception" do
+          lambda { klass.send(meth) }.should raise_error(Helix::NoConfigurationLoaded)
+        end
+      end
+      context "when a Helix:Config instance is present" do
         before(:each) do
-          klass.stub(:attributes) { mock_attrs }
-          klass.stub(:guid_name)  { guid_name  }
-          klass.stub(:new)        { mock_obj }
+          klass.stub(:plural_resource_label) { :klasses }
+          klass.stub(:resource_label_sym)    { klass_sym }
+          mock_config.stub(:build_url).with(content_type: :xml, resource_label: :klasses) { :url }
+          mock_config.stub(:signature).with(:update) { "some_sig" }
+          Helix::Config.stub(:instance) { mock_config }
         end
-        context "and the guid is nil" do
-          it "should raise an ArgumentError complaining about a nil guid" do
-            msg = 'find requires a non-nil guid argument - received a nil argument.'
-            lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
-          end
+        it "should get an ingest signature" do
+          mock_config.should_receive(:build_url).with(resource_label: :klasses,
+                                                      content_type:   :xml)
+          RestClient.stub(:post).with(:url, params) { resp_json }
+          Hash.should_receive(:from_xml).with(resp_json) { resp_value }
+          klass.stub(:new).with(expected)
+          mock_config.should_receive(:signature).with(:update) { "some_sig" }
+          klass.send(meth)
         end
-        context "and the guid is non-nil" do
-          let(:guid) { :a_guid }
-          it "should raise a NoConfigurationLoaded exception" do
-            lambda { klass.send(meth, guid) }.should raise_error(Helix::NoConfigurationLoaded)
-          end
+        it "should do an HTTP post call, parse response and call new" do
+          mock_config.should_receive(:build_url).with(resource_label: :klasses,
+                                                      content_type:   :xml)
+          RestClient.should_receive(:post).with(:url, params) { resp_json }
+          Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
+          klass.should_receive(:new).with(expected)
+          klass.send(meth)
         end
       end
     end
-    context "when a Helix::Config instance is present" do
-      before(:each) do Helix::Config.stub(:instance) { mock_config } end
-      context "and given a guid" do
-        let(:guid_name)  { :the_guid_name }
-        let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
-        before(:each) do
-          klass.stub(:attributes) { mock_attrs }
-          klass.stub(:guid_name)  { guid_name  }
-          klass.stub(:new)        { mock_obj }
-        end
-        context "and the guid is nil" do
-          it "should raise an ArgumentError complaining about a nil guid" do
-            msg = 'find requires a non-nil guid argument - received a nil argument.'
-            lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
+
+    describe ".find" do
+      let(:meth)        { :find }
+      let(:mock_config) { mock(Helix::Config) }
+      let(:mock_obj)    { mock(klass, :load => :output_of_load) }
+      subject     { klass.method(meth) }
+      its(:arity) { should eq(1) }
+      context "when a Helix:Config instance is absent" do
+        before(:each) do Helix::Config.stub(:instance) { nil } end
+        context "and given a guid" do
+          let(:guid_name)  { :the_guid_name }
+          let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
+          before(:each) do
+            klass.stub(:attributes) { mock_attrs }
+            klass.stub(:guid_name)  { guid_name  }
+            klass.stub(:new)        { mock_obj }
+          end
+          context "and the guid is nil" do
+            it "should raise an ArgumentError complaining about a nil guid" do
+              msg = 'find requires a non-nil guid argument - received a nil argument.'
+              lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
+            end
+          end
+          context "and the guid is non-nil" do
+            let(:guid) { :a_guid }
+            it "should raise a NoConfigurationLoaded exception" do
+              lambda { klass.send(meth, guid) }.should raise_error(Helix::NoConfigurationLoaded)
+            end
           end
         end
-        context "and the guid is non-nil" do
-          let(:guid) { :a_guid }
-          it "should instantiate with {attributes: guid_name => the_guid, config: config}" do
-            klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
-            klass.send(meth, guid)
+      end
+      context "when a Helix::Config instance is present" do
+        before(:each) do Helix::Config.stub(:instance) { mock_config } end
+        context "and given a guid" do
+          let(:guid_name)  { :the_guid_name }
+          let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
+          before(:each) do
+            klass.stub(:attributes) { mock_attrs }
+            klass.stub(:guid_name)  { guid_name  }
+            klass.stub(:new)        { mock_obj }
+          end
+          context "and the guid is nil" do
+            it "should raise an ArgumentError complaining about a nil guid" do
+              msg = 'find requires a non-nil guid argument - received a nil argument.'
+              lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
+            end
           end
-          it "should load" do
-            mock_obj.should_receive(:load)
-            klass.send(meth, guid)
+          context "and the guid is non-nil" do
+            let(:guid) { :a_guid }
+            it "should instantiate with {attributes: guid_name => the_guid, config: config}" do
+              klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
+              klass.send(meth, guid)
+            end
+            it "should load" do
+              mock_obj.should_receive(:load)
+              klass.send(meth, guid)
+            end
           end
         end
       end
     end
-  end
 
-  describe "an instance" do
-    let(:obj) { klass.new({}) }
+    child_classes = [ Helix::Album, Helix::Image, Helix::Track, Helix::Video ]
+    child_classes.each do |child_class|
+      describe "an instance of #{child_class.to_s}" do
+        let(:obj) { child_class.new({}) }
 
-    describe "#destroy" do
-      let(:meth)   { :destroy }
-      let(:mock_config) { mock(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
-      subject      { obj.method(meth) }
-      let(:params) { { params: {signature: :some_sig } } }
-      before do
-        obj.stub(:config)            { mock_config }
-        obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_resource_label) { :resource_label }
-      end
-      it "should get an update signature" do
-        url = mock_config.build_url(resource_label: :resource_label,
-                                    guid:           :some_guid,
-                                    content_type:   :xml)
-        RestClient.stub(:delete).with(url, params)
-        mock_config.should_receive(:signature).with(:update) { :some_sig }
-        obj.send(meth)
-      end
-      it "should call for an HTTP delete and return nil" do
-        url = mock_config.build_url(resource_label: :resource_label,
-                                    guid:           :some_guid,
-                                    content_type:   :xml)
-        RestClient.should_receive(:delete).with(url, params)
-        expect(obj.send(meth)).to be_nil
-      end
-    end
-    describe "#update" do
-      let(:meth)  { :update }
-      let(:mock_config) { mock(Helix::Config) }
-      subject     { obj.method(meth) }
-      its(:arity) { should eq(-1) }
-      before(:each) do
-        obj.stub(:config) { mock_config }
-        obj.stub(:guid)   { :the_guid }
-        obj.stub(:resource_label_sym) { :video }
-        obj.stub(:plural_resource_label) { :the_resource_label }
-        mock_config.stub(:signature).with(:update) { 'some_sig' }
-        mock_config.stub(:build_url) { :expected_url }
-      end
-      shared_examples_for "builds URL for update" do
-        it "should build_url(content_type: :xml, guid: guid, resource_label: plural_resource_label)" do
-          mock_config.should_receive(:build_url).with(content_type: :xml, guid: :the_guid, resource_label: :the_resource_label)
-          RestClient.stub(:put)
-          obj.send(meth)
-        end
-        it "should get an update signature" do
-          mock_config.stub(:build_url)
-          RestClient.stub(:put)
-          mock_config.should_receive(:signature).with(:update) { 'some_sig' }
-          obj.send(meth)
-        end
-      end
-      context "when given no argument" do
-        it_behaves_like "builds URL for update"
-        it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: {}}) and return instance of klass" do
-          RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: {}})
-          expect(obj.send(meth)).to be_an_instance_of(klass)
-        end
-      end
-      context "when given an opts argument of {key1: :value1}" do
-        let(:opts)  { {key1: :value1} }
-        it_behaves_like "builds URL for update"
-        it "clones the opts arg" do
-          RestClient.stub(:put).with(:expected_url, {signature: 'some_sig', video: opts})
-          opts.should_receive(:clone) { opts }
-          obj.send(meth, opts)
+        describe "#destroy" do
+          let(:meth)   { :destroy }
+          let(:mock_config) { mock(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
+          subject      { obj.method(meth) }
+          let(:params) { { params: {signature: :some_sig } } }
+          before do
+            obj.stub(:config)            { mock_config }
+            obj.stub(:guid)              { :some_guid  }
+            obj.stub(:plural_resource_label) { :resource_label }
+          end
+          it "should get an update signature" do
+            url = mock_config.build_url(resource_label: :resource_label,
+                                        guid:           :some_guid,
+                                        content_type:   :xml)
+            RestClient.stub(:delete).with(url, params)
+            mock_config.should_receive(:signature).with(:update) { :some_sig }
+            obj.send(meth)
+          end
+          it "should call for an HTTP delete and return nil" do
+            url = mock_config.build_url(resource_label: :resource_label,
+                                        guid:           :some_guid,
+                                        content_type:   :xml)
+            RestClient.should_receive(:delete).with(url, params)
+            expect(obj.send(meth)).to be_nil
+          end
         end
-        it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: opts}) and return instance of klass" do
-          RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: opts})
-          expect(obj.send(meth, opts)).to be_an_instance_of(klass)
+        describe "#update" do
+          next if child_class == Helix::Album
+          let(:meth)  { :update }
+          let(:mock_config) { mock(Helix::Config) }
+          subject     { obj.method(meth) }
+          its(:arity) { should eq(-1) }
+          before(:each) do
+            obj.stub(:config) { mock_config }
+            obj.stub(:guid)   { :the_guid }
+            obj.stub(:resource_label_sym) { :video }
+            obj.stub(:plural_resource_label) { :the_resource_label }
+            mock_config.stub(:signature).with(:update) { 'some_sig' }
+            mock_config.stub(:build_url) { :expected_url }
+          end
+          shared_examples_for "builds URL for update" do
+            it "should build_url(content_type: :xml, guid: guid, resource_label: plural_resource_label)" do
+              mock_config.should_receive(:build_url).with(content_type: :xml, guid: :the_guid, resource_label: :the_resource_label)
+              RestClient.stub(:put)
+              obj.send(meth)
+            end
+            it "should get an update signature" do
+              mock_config.stub(:build_url)
+              RestClient.stub(:put)
+              mock_config.should_receive(:signature).with(:update) { 'some_sig' }
+              obj.send(meth)
+            end
+          end
+          context "when given no argument" do
+            it_behaves_like "builds URL for update"
+            it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: {}}) and return instance of klass" do
+              RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: {}})
+              expect(obj.send(meth)).to be_an_instance_of(child_class)
+            end
+          end
+          context "when given an opts argument of {key1: :value1}" do
+            let(:opts)  { {key1: :value1} }
+            it_behaves_like "builds URL for update"
+            it "clones the opts arg" do
+              RestClient.stub(:put).with(:expected_url, {signature: 'some_sig', video: opts})
+              opts.should_receive(:clone) { opts }
+              obj.send(meth, opts)
+            end
+            it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: opts}) and return instance of klass" do
+              RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: opts})
+              expect(obj.send(meth, opts)).to be_an_instance_of(child_class)
+            end
+          end
         end
       end
     end

data/spec/statistics_spec.rb

@@ -24,6 +24,13 @@ describe Helix::Statistics do
     end
   end
 
+  shared_examples_for "standardizes raw stats" do
+    it "should return standardize_raw_stats(raw)" do
+      mod.should_receive(:standardize_raw_stats).with(:raw_response) { :response }
+      expect(mod.send(meth, opts)).to eq(:response)
+    end
+  end
+
   STATS_TYPES.each do |stats_type|
     STATS_MEDIA_TYPES.each do |resource_label|
 
@@ -31,8 +38,11 @@ describe Helix::Statistics do
 
       describe ".#{resource_label}_#{stats_type}" do
         let(:meth)  { "#{resource_label}_#{stats_type}" }
-        let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: :response) }
-        before(:each) do Helix::Config.stub(:instance) { mock_config } end
+        let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: :raw_response) }
+        before(:each) do
+          Helix::Config.stub(:instance) { mock_config }
+          mod.stub(:standardize_raw_stats).with(:raw_response) { :response }
+        end
 
         subject     { mod.method(meth) }
         its(:arity) { should eq(-1)    }
@@ -76,10 +86,11 @@ describe Helix::Statistics do
                   mod.send(meth, opts)
                 end
               end
-              it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
-                mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :response }
-                expect(mod.send(meth, opts)).to eq(:response)
+              it "should assign config.get_response(built_url, opts.merge(sig_type: :view) => raw" do
+                mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :raw_response }
+                mod.send(meth, opts)
               end
+              it_behaves_like "standardizes raw stats"
             end
             context "when given opts NOT containing a :#{media_name}_id" do
               let(:opts) { {group: :daily} }
@@ -112,10 +123,11 @@ describe Helix::Statistics do
                   mod.send(meth, opts)
                 end
               end
-              it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
-                mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :response }
-                expect(mod.send(meth, opts)).to eq(:response)
+              it "should assign config.get_response(built_url, opts.merge(sig_type: :view) => raw" do
+                mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :raw_response }
+                mod.send(meth, opts)
               end
+              it_behaves_like "standardizes raw stats"
             end
           when 'ingest'
             media_name   = MEDIA_NAME_OF[resource_label]  || resource_label
@@ -132,10 +144,11 @@ describe Helix::Statistics do
                   mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_#{publish_name}/breakdown".to_sym}) { :built_url }
                   mod.send(meth, opts)
                 end
-                it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
-                  mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :response }
-                  expect(mod.send(meth, opts)).to eq(:response)
+                it "should assign config.get_response(built_url, opts.merge(sig_type: :view) => raw" do
+                  mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :raw_response }
+                  mod.send(meth, opts)
                 end
+                it_behaves_like "standardizes raw stats"
               end
               [ :encode, :source, :breakdown ].each do |act|
                 context "and opts has an :action value of :#{act}" do
@@ -149,10 +162,11 @@ describe Helix::Statistics do
                     mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_#{publish_name}/#{act}".to_sym}) { :built_url }
                     mod.send(meth, opts)
                   end
-                  it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
-                    mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :response }
-                    expect(mod.send(meth, opts)).to eq(:response)
+                  it "should assign config.get_response(built_url, opts.merge(sig_type: :view) => raw" do
+                    mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :raw_response }
+                    mod.send(meth, opts)
                   end
+                  it_behaves_like "standardizes raw stats"
                 end
               end
             end
@@ -170,10 +184,11 @@ describe Helix::Statistics do
                 mock_config.should_receive(:build_url).with({resource_label: :statistics, action: "#{media_name}_#{publish_name}/disk_usage".to_sym}) { :built_url }
                 mod.send(meth, opts)
               end
-              it "should return config.get_response(built_url, opts.merge(sig_type: :view)" do
-                mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :response }
-                expect(mod.send(meth, opts)).to eq(:response)
+              it "should assign config.get_response(built_url, opts.merge(sig_type: :view) => raw" do
+                mock_config.should_receive(:get_response).with(:built_url, {group: :daily, sig_type: :view}) { :raw_response }
+                mod.send(meth, opts)
               end
+              it_behaves_like "standardizes raw stats"
             end
           # nested in for case
         end
@@ -242,4 +257,24 @@ describe Helix::Statistics do
 
   end
 
+  describe "#standardize_raw_stats" do
+    let(:meth) { :standardize_raw_stats }
+    describe "arity" do
+      subject { mod.method(meth) }
+      its(:arity) { should eq(1) }
+    end
+    args = [ [], {}, { some_key: :some_value } ]
+    args.each do |arg|
+      context "when given #{arg.inspect}" do
+        it "should eq #{arg.inspect}" do
+          expect(mod.send(meth, arg)).to eq(arg)
+        end
+      end
+    end
+    context "when given {'statistics_reports' => :expected}" do
+      subject { mod.send(meth, {'statistics_reports' => :expected}) }
+      it { should eq(:expected) }
+    end
+  end
+
 end