whisperer 0.0.1

data/spec/unit/preprocessors/content_length_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Whisperer::Preprocessors::ContentLength do
+  describe '#process' do
+    subject { described_class.new(record) }
+
+    context 'when a content length for a response is defined' do
+      let(:record) {
+        r = Whisperer::Record.new
+        r.response.headers.content_length = '10'
+        r
+      }
+
+      it 'record has a unchanged content length' do
+        subject.process
+
+        expect(record.response.headers.content_length).to eq('10')
+      end
+    end
+
+    context 'when a content length for a response is not defined' do
+      let(:record) {
+        Whisperer::Record.new(
+          response: {
+            body: {
+              string: 'test'
+            }
+          }
+        )
+      }
+
+      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')
+      end
+    end
+  end
+end

data/spec/unit/preprocessors/response_body_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Whisperer::Preprocessors::ResponseBody do
+  describe '#process' do
+    subject { described_class.new(record) }
+
+    context 'when there is not data object' do
+      let(:record) { Whisperer::Record.new }
+
+      it 'does not serialize anything' do
+        expect(Whisperer).to_not receive(:serializer)
+
+        subject.process
+      end
+    end
+
+    context 'when there is data object' do
+      let(:serialized_data) { 'serialized data' }
+      let(:serializer)      { double('Serializer', serialize: true) }
+
+      let(:data_obj) { OpenStruct.new(test: 'obj') }
+
+      let(:record) {
+        r = Whisperer::Record.new
+        r.response.body.data_obj   = data_obj
+        r.response.body.serializer = :json
+        r.response.body.serializer_opts = {some: 'options'}
+        r
+      }
+
+      before do
+        allow(Whisperer).to receive(:serializer).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)
+
+        subject.process
+      end
+
+      it 'serializes the respose body' do
+        expect(serializer).to receive(:serialize).with(data_obj, {some: 'options'})
+
+        subject.process
+      end
+
+      it 'assigns the serialized data to the record' do
+        subject.process
+
+        expect(record.response.body.string).to eq(serialized_data)
+      end
+    end
+  end
+end

data/spec/unit/preprocessors_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Whisperer::Preprocessors do
+  describe '.process' do
+    it 'processes the container with A processor'
+    it 'processes the container with B processor'
+  end
+end

data/spec/unit/record/headers_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Whisperer::Headers do
+  describe '.to_hash' do
+    subject {
+      obj = described_class.new()
+
+      obj.attribute(:content_type, String)
+      obj.attributes = {
+        content_type: 'json'
+      }
+      obj
+    }
+
+    it 'returns a hash with correct keys' do
+      expect(subject.to_hash).to eq(
+        'Content-Type' => 'json'
+      )
+    end
+  end
+end

data/spec/unit/record/response_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Whisperer::Response do
+  describe '.headers' do
+    subject { described_class.new }
+
+    it 'has a content length field' do
+      expect(subject.headers).to respond_to(:content_length)
+    end
+  end
+end

data/spec/unit/record_spec.rb

@@ -0,0 +1,77 @@
+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/base_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Whisperer::Serializers::Base do
+  let(:options) { {test: 1} }
+
+  subject { described_class.new(nil, options: options) }
+
+  describe '.new' do
+    it 'keeps given options' do
+      expect(subject.options).to eq(options)
+    end
+  end
+
+  describe '#serialize' do
+    it 'raises an error about implementation' do
+      expect{ subject.serialize }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/unit/serializers/json_multiple_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Whisperer::Serializers::JsonMultiple do
+  describe '#serialize' do
+    let(:attrs) {
+      {
+        first_name: 'John',
+        last_name:  'Snow'
+      }
+    }
+
+    let(:data) {
+      [
+        OpenStruct.new(attrs)
+      ]
+    }
+
+    subject { described_class.new(data) }
+
+    it 'returns json string with a serialized array' do
+      expect(subject.serialize).to eq('[{"first_name":"John","last_name":"Snow"}]')
+    end
+  end
+end

data/spec/unit/serializers/json_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+class TestChildJson < Whisperer::Serializers::Json
+  protected
+    def post_prepare_data(data)
+      {test: data}
+    end
+end
+
+describe Whisperer::Serializers::Json do
+  describe '#serialize' do
+    let(:attrs) {
+      {
+        first_name: 'John',
+        last_name:  'Snow'
+      }
+    }
+
+    subject { described_class.new(OpenStruct.new(attrs)) }
+
+    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(OpenStruct.new(attrs)) }
+
+      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
+end

data/spec/unit/whisperer_spec.rb

@@ -0,0 +1,189 @@
+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) {}
+
+      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
+    end
+  end
+
+  describe '.defined_any?' do
+    context 'when there are defined cassette records' do
+      before do
+        described_class.cassette_records[:test] = true
+      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,
+          'There is not cassette builder with "mytest" name.'
+        )
+      end
+    end
+
+    context 'when the cassette with the given name exists' do
+      shared_examples 'generator' do |name|
+        it 'generates the VCR cassette' do
+          expect(Whisperer::Generator).to receive(:generate).with(
+            cassette_record,
+            :test
+          )
+
+          described_class.generate(name)
+        end
+      end
+
+      let(:cassette_record) { double }
+
+      before do
+        described_class.cassette_records[:test] = cassette_record
+      end
+
+      context 'when the given name is a symbol' do
+        it_behaves_like 'generator', :test
+      end
+
+      context 'when the given name is a string' do
+        it_behaves_like 'generator', 'test'
+      end
+    end
+  end
+
+  describe '.generate_all' do
+    context 'when there are defined cassettes' do
+      let(:record1) { double('cassette record 1') }
+      let(:record2) { double('cassette record 2') }
+
+      before do
+        Whisperer::cassette_records[:record1] = record1
+        Whisperer::cassette_records[:record2] = record2
+
+        allow(Whisperer).to receive(:defined_any?).and_return(true)
+        allow(Whisperer).to receive(:generate)
+      end
+
+      it 'generates the VCR cassette based on record1' do
+        expect(Whisperer).to receive(:generate).with(:record1)
+
+        described_class.generate_all
+      end
+
+      it 'generates the VCR cassette based on record2' do
+        expect(Whisperer).to receive(:generate).with(:record2)
+
+        described_class.generate_all
+      end
+    end
+
+    context 'when there are not defined cassette records' do
+      before do
+        allow(Whisperer).to receive(:defined_any?).and_return(false)
+      end
+
+      it 'raises and error' do
+        expect { described_class.generate_all }.to raise_error(
+          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
+
+    context 'when there is such serializer' do
+      it 'returns the registered class' do
+        expect(described_class.serializer(:json)).to eq(Whisperer::Serializers::Json)
+      end
+    end
+  end
+
+  describe '.register_preprocessor' do
+    it 'registers preprocessor' do
+      expect(Whisperer::Preprocessors).to receive(:register).with('some name', 'some class')
+
+      Whisperer.register_preprocessor('some name', 'some class')
+    end
+  end
+end