whisperer 0.0.1 → 0.0.2

data/spec/unit/preprocessors/content_length_spec.rb

@@ -6,15 +6,19 @@ describe Whisperer::Preprocessors::ContentLength do
 
     context 'when a content length for a response is defined' do
       let(:record) {
-        r = Whisperer::Record.new
-        r.response.headers.content_length = '10'
-        r
+        Whisperer::Record.new(
+          response: {
+            headers: {
+              content_length: 10
+            }
+          }
+        )
       }
 
       it 'record has a unchanged content length' do
         subject.process
 
-        expect(record.response.headers.content_length).to eq('10')
+        expect(record.response.headers.content_length).to eq(10)
       end
     end
 
@@ -32,7 +36,7 @@ describe Whisperer::Preprocessors::ContentLength do
       it 'measures size of body and writes it to the content length header of the response' do
         subject.process
 
-        expect(record.response.headers.content_length).to eq('4')
+        expect(record.response.headers.content_length).to eq(4)
       end
     end
   end

data/spec/unit/preprocessors/default_values_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Whisperer::Preprocessors::DefaultValues do
+  describe '#process' do
+    let(:record) {
+      r = Whisperer::Record.new
+      r.request.method       = Whisperer::DefaultValue.new(:get)
+      r.response.status.code = Whisperer::DefaultValue.new(200)
+      r
+    }
+
+    subject { described_class.new(record) }
+
+    before do
+      subject.process
+    end
+
+    it 'has correct value for the request method' do
+      expect(record.request.method).to eq(:get)
+    end
+
+    it 'has correct value for the response status' do
+      expect(record.response.status.code).to eq(200)
+    end
+  end
+end

data/spec/unit/preprocessors/response_body_spec.rb

@@ -8,7 +8,7 @@ describe Whisperer::Preprocessors::ResponseBody do
       let(:record) { Whisperer::Record.new }
 
       it 'does not serialize anything' do
-        expect(Whisperer).to_not receive(:serializer)
+        expect(Whisperer::Serializers).to_not receive(:fetch)
 
         subject.process
       end
@@ -29,17 +29,17 @@ describe Whisperer::Preprocessors::ResponseBody do
       }
 
       before do
-        allow(Whisperer).to receive(:serializer).and_return(serializer)
+        allow(Whisperer::Serializers).to receive(:fetch).and_return(serializer)
         allow(serializer).to receive(:serialize).and_return(serialized_data)
       end
 
       it 'gets the serializer' do
-        expect(Whisperer).to receive(:serializer).with(:json)
+        expect(Whisperer::Serializers).to receive(:fetch).with(:json)
 
         subject.process
       end
 
-      it 'serializes the respose body' do
+      it 'serializes the response body' do
         expect(serializer).to receive(:serialize).with(data_obj, {some: 'options'})
 
         subject.process

data/spec/unit/record/headers_spec.rb

@@ -1,7 +1,19 @@
 require 'spec_helper'
 
 describe Whisperer::Headers do
-  describe '.to_hash' do
+  describe '.new' do
+    context 'when there is not such attribute' do
+      subject {
+        described_class.new(connection: 'keep-alive')
+      }
+
+      it 'adds them dynamically' do
+        expect(subject.connection).to eq('keep-alive')
+      end
+    end
+  end
+
+  describe '#to_hash' do
     subject {
       obj = described_class.new()
 

data/spec/unit/record_spec.rb

@@ -1,77 +1,4 @@
 require 'spec_helper'
 
 describe Whisperer::Record do
-  describe '#merge!' do
-    let(:record)         {
-      r = Whisperer::Record.new(
-        request: {
-          uri: 'http://google.com',
-        },
-        response: {
-          body: {
-            encoding: 'UTF-8',
-            string:   'test'
-          }
-        },
-        recorded_at: 'test data'
-      )
-
-      r.request.headers.attribute(:content_length, Integer)
-      r.request.headers.attribute(:accept, String)
-
-      r.request.headers.content_length = 100
-      r.request.headers.accept         = 'javascript'
-      r
-    }
-
-    let(:another_record) {
-      r = Whisperer::Record.new(
-        request: {
-          headers: {
-            content_length: 50
-          }
-        },
-        response: {
-          body: {
-            encoding: 'UTF-16'
-          }
-        }
-      )
-
-      r.request.headers.attribute(:content_length, Integer)
-
-      r.request.headers.content_length = 50
-      r
-    }
-
-    subject { another_record }
-
-    before do
-      subject.merge!(record)
-    end
-
-    it 'has a correct content length header for the request' do
-      expect(subject.request.headers.content_length).to eq(50)
-    end
-
-    it 'has an accept header for the request' do
-      expect(subject.request.headers.accept).to eq('javascript')
-    end
-
-    it 'has an url' do
-      expect(subject.request.uri).to eq('http://google.com')
-    end
-
-    it 'has a correct encoding for the body of the response' do
-      expect(subject.response.body.encoding).to eq('UTF-16')
-    end
-
-    it 'has a string for the body of the response' do
-      expect(subject.response.body.string).to eq('test')
-    end
-
-    it 'has a correct recorded_at value' do
-      expect(subject.recorded_at).to eq('test data')
-    end
-  end
 end

data/spec/unit/serializers/json_spec.rb

@@ -7,8 +7,48 @@ class TestChildJson < Whisperer::Serializers::Json
     end
 end
 
+class TestObj
+  def initialize(attrs)
+    @first_name = attrs[:first_name]
+    @last_name  = nil
+  end
+
+  # we need to make sure that our serializer uses accessors methods
+  # when it exists.
+  def last_name
+    'Snow'
+  end
+end
+
+class TestObjWithAttrs
+  def attributes
+    {
+      first_name: 'John',
+      last_name:  'Snow'
+    }
+  end
+end
+
 describe Whisperer::Serializers::Json do
   describe '#serialize' do
+    shared_examples 'serializing an object' do
+      it 'returns json string with serialized attributes' do
+        expect(subject.serialize).to eq('{"first_name":"John","last_name":"Snow"}')
+      end
+
+      context 'when the class is inherited' do
+        subject { TestChildJson.new(given_obj) }
+
+        context 'when the child class alters the data structure' do
+          it 'returns the altered structure' do
+            expect(subject.serialize).to eq(
+              '{"test":{"first_name":"John","last_name":"Snow"}}'
+            )
+          end
+        end
+      end
+    end
+
     let(:attrs) {
       {
         first_name: 'John',
@@ -16,22 +56,30 @@ describe Whisperer::Serializers::Json do
       }
     }
 
-    subject { described_class.new(OpenStruct.new(attrs)) }
+    subject { described_class.new(given_obj) }
+
+    context 'when an open struct object is given' do
+      let(:given_obj) {
+        OpenStruct.new(attrs)
+      }
+
+      it_behaves_like 'serializing an object'
+    end
+
+    context 'When a pure ruby object is given' do
+      let(:given_obj) {
+        TestObj.new(attrs)
+      }
 
-    it 'returns json string with serialized attributes' do
-      expect(subject.serialize).to eq('{"first_name":"John","last_name":"Snow"}')
+      it_behaves_like 'serializing an object'
     end
 
-    context 'when the class is inherited' do
-      subject { TestChildJson.new(OpenStruct.new(attrs)) }
+    context 'when an object has the attributes method' do
+      let(:given_obj) {
+        TestObjWithAttrs.new
+      }
 
-      context 'when the child class alters the data structure' do
-        it 'returns the altered structure' do
-          expect(subject.serialize).to eq(
-            '{"test":{"first_name":"John","last_name":"Snow"}}'
-          )
-        end
-      end
+      it_behaves_like 'serializing an object'
     end
   end
 end

data/spec/unit/serializers_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Whisperer::Serializers do
+  describe '.fetch' do
+    before do
+      described_class.register(:test_json, 'My test class')
+    end
+
+    context 'when there is not such serializer' do
+      it 'raises an error' do
+        expect { described_class.fetch(:mytest) }.to raise_error(
+          ArgumentError,
+          'There is not serializer registered with "mytest" name'
+        )
+      end
+    end
+
+    context 'when there is such serializer' do
+      it 'returns the registered class' do
+        expect(described_class.fetch(:test_json)).to eq('My test class')
+      end
+    end
+  end
+end

data/spec/unit/storage_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Whisperer::Storage do
+  describe '.define' do
+    let(:cassette_record) { instance_double('Whisperer::Record') }
+    let(:dsl)             { instance_double('Whisperer::Dsl', container: cassette_record) }
+
+    before do
+      allow(Whisperer::Dsl).to receive(:build).and_return(dsl)
+    end
+
+    after do
+      described_class.reset_storage
+    end
+
+    it 'builds the dsl object' do
+      expect(Whisperer::Dsl).to receive(:build)
+
+      described_class.define(:test) {}
+    end
+
+    it 'executes a given block over the dsl object' do
+      expect(dsl).to receive(:request)
+
+      described_class.define(:test) {
+        request
+      }
+    end
+
+    it 'stores the generated cassette record' do
+      described_class.define(:test) {}
+
+      expect(described_class.cassette_record(:test)).to eq(cassette_record)
+      expect(described_class.defined_any?).to be_truthy
+    end
+
+    context 'when a string as a name of the cassette record is given' do
+      it 'stores a cassette record with a symbol key' do
+        described_class.define('test') {}
+
+        expect(described_class.cassette_record(:test)).to eq(cassette_record)
+      end
+    end
+
+    context 'when a parent is defined for a cassette record' do
+      context 'when such parent exists' do
+        let(:orig_cassette_record) { double('original cassette record') }
+
+        before do
+          expect(described_class).to receive(:cassette_record).with(:some_parent).and_return(
+            orig_cassette_record
+          )
+        end
+
+        it 'merges the original record with the newly built' do
+          expect(Whisperer::Merger).to receive(:merge).with(
+            cassette_record,
+            orig_cassette_record
+          )
+
+          described_class.define('test', parent: :some_parent) {}
+        end
+      end
+
+      context 'when such parent does not exist' do
+        it 'raises an error' do
+          expect {
+            described_class.define('test', parent: :some_parent) {}
+          }.to raise_error(ArgumentError, 'Parent record "some_parent" is not declared.')
+        end
+      end
+    end
+  end
+
+  describe '.defined_any?' do
+    context 'when there are not defined cassette_records' do
+      it 'returns false' do
+        expect(described_class.defined_any?).to be_falsey
+      end
+    end
+  end
+end

data/spec/unit/whisperer_spec.rb

@@ -1,94 +1,25 @@
 require 'spec_helper'
 
 describe Whisperer do
-  after do
-    described_class.cassette_records.clear
-  end
-
   describe '.define' do
-    let(:cassette_record) { instance_double('Whisperer::Record', merge!: true) }
-    let(:dsl)            { instance_double('Whisperer::Dsl', container: cassette_record) }
-
-    before do
-      allow(Whisperer::Dsl).to receive(:build).and_return(dsl)
-    end
-
-    it 'builds the dsl object' do
-      expect(Whisperer::Dsl).to receive(:build)
-
-      described_class.define(:test) {}
-    end
-
-    it 'executes a given block over the dsl object' do
-      expect(dsl).to receive(:request)
-
-      described_class.define(:test) {
-        request
-      }
-    end
-
-    it 'stores the generated cassette record' do
-      described_class.define(:test) {}
+    it 'proxies to the storage class' do
+      expect(Whisperer::Storage).to receive(:define).with(
+        'test arg'
+      )
 
-      expect(Whisperer.cassette_records[:test]).to eq(cassette_record)
-    end
-
-    context 'when a string as a name of the cassette record is given' do
-      it 'stores a cassette record with a symbol key' do
-        described_class.define('test') {}
-
-        expect(Whisperer.cassette_records[:test]).to eq(cassette_record)
-      end
-    end
-
-    context 'when a parent is defined for a cassette record' do
-      context 'when such parent exists' do
-        let(:orig_cassette_record) { double('original cassette record') }
-
-        before do
-          Whisperer.cassette_records[:some_parent] = orig_cassette_record
-        end
-
-        it 'merges the original record with the newly built' do
-          expect(cassette_record).to receive(:merge!).with(orig_cassette_record)
-
-          described_class.define('test', parent: :some_parent) {}
-        end
-      end
-
-      context 'when such parent does not exist' do
-        it 'raises an error' do
-          expect {
-            described_class.define('test', parent: :some_parent) {}
-          }.to raise_error(ArgumentError, 'Parent record "some_parent" is not declared.')
-        end
-      end
+      described_class.define('test arg')
     end
   end
 
-  describe '.defined_any?' do
-    context 'when there are defined cassette records' do
+  describe '.generate' do
+    context 'when the cassette record with the given name does not exist' do
       before do
-        described_class.cassette_records[:test] = true
+        expect(Whisperer::Storage).to receive(:cassette_record).and_return(nil)
       end
 
-      it 'returns true' do
-        expect(Whisperer.defined_any?).to be_truthy
-      end
-    end
-
-    context 'when there are not defined cassette_records' do
-      it 'returns false' do
-        expect(Whisperer.defined_any?).to be_falsey
-      end
-    end
-  end
-
-  describe '.generate' do
-    context 'when the cassette record with the given name does not exist' do
       it 'raises an error' do
         expect { described_class.generate(:mytest) }.to raise_error(
-          Whisperer::NocassetteRecordError,
+          Whisperer::NoCassetteRecordError,
           'There is not cassette builder with "mytest" name.'
         )
       end
@@ -109,7 +40,7 @@ describe Whisperer do
       let(:cassette_record) { double }
 
       before do
-        described_class.cassette_records[:test] = cassette_record
+        expect(Whisperer::Storage).to receive(:cassette_record).with(:test).and_return(cassette_record)
       end
 
       context 'when the given name is a symbol' do
@@ -124,25 +55,33 @@ describe Whisperer do
 
   describe '.generate_all' do
     context 'when there are defined cassettes' do
-      let(:record1) { double('cassette record 1') }
-      let(:record2) { double('cassette record 2') }
+      let(:record1) { double('Cassette record 1') }
+      let(:record2) { double('Cassette record 2') }
 
       before do
-        Whisperer::cassette_records[:record1] = record1
-        Whisperer::cassette_records[:record2] = record2
+        expect(Whisperer::Storage).to receive(:cassette_records).and_return(
+          record1: record1,
+          record2: record2
+        )
 
-        allow(Whisperer).to receive(:defined_any?).and_return(true)
-        allow(Whisperer).to receive(:generate)
+        allow(Whisperer::Storage).to receive(:defined_any?).and_return(true)
+        allow(Whisperer::Generator).to receive(:generate)
       end
 
       it 'generates the VCR cassette based on record1' do
-        expect(Whisperer).to receive(:generate).with(:record1)
+        expect(Whisperer::Generator).to receive(:generate).with(
+          record1,
+          :record1
+        )
 
         described_class.generate_all
       end
 
       it 'generates the VCR cassette based on record2' do
-        expect(Whisperer).to receive(:generate).with(:record2)
+        expect(Whisperer::Generator).to receive(:generate).with(
+          record2,
+          :record2
+        )
 
         described_class.generate_all
       end
@@ -155,32 +94,23 @@ describe Whisperer do
 
       it 'raises and error' do
         expect { described_class.generate_all }.to raise_error(
-          Whisperer::NocassetteRecordError,
-          'cassette builders are not found.'
+          Whisperer::NoCassetteRecordError,
+          'Cassette builders are not found.'
         )
       end
     end
   end
 
-  describe '.serializer' do
-    context 'when there is not such serializer' do
-      it 'raises an error' do
-        expect { described_class.serializer(:mytest) }.to raise_error(
-          ArgumentError,
-          'There is not serializer registered with "mytest" name'
-        )
-      end
-    end
+  describe '.register_serializer' do
+    it 'registers a serializer' do
+      expect(Whisperer::Serializers).to receive(:register).with('some name', 'some class')
 
-    context 'when there is such serializer' do
-      it 'returns the registered class' do
-        expect(described_class.serializer(:json)).to eq(Whisperer::Serializers::Json)
-      end
+      Whisperer.register_serializer('some name', 'some class')
     end
   end
 
   describe '.register_preprocessor' do
-    it 'registers preprocessor' do
+    it 'registers a preprocessor' do
       expect(Whisperer::Preprocessors).to receive(:register).with('some name', 'some class')
 
       Whisperer.register_preprocessor('some name', 'some class')