whisperer 0.0.1

data/spec/unit/convertors/hash_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Test
+  class Status
+    include Virtus.model
+
+    attribute :code, Integer
+  end
+
+  class Position
+    include Virtus.model
+
+    attribute :name
+    attribute :status, Status
+  end
+
+  class User
+    include Virtus.model
+
+    attribute :name,     String
+    attribute :position, Test::Position
+  end
+end
+
+describe Whisperer::Convertors::Hash do
+  describe '#convert' do
+    let(:attrs) {
+      {
+        name:     'Tester',
+        position: {
+          name: 'developer',
+          status: {
+            code: 1
+          }
+        }
+      }
+    }
+
+    let(:expected_attrs) {
+      {
+        'name'      => 'Tester',
+        'position'  => {
+          'name'    => 'developer',
+          'status'  => {
+            'code'  => 1
+          }
+        }
+      }
+    }
+
+    subject { described_class.new(Test::User.new(attrs)) }
+
+    it 'returns a hash with all related objects' do
+      expect(subject.convert).to eq(
+        expected_attrs
+      )
+    end
+  end
+end

data/spec/unit/convertors/interaction_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Whisperer::Convertors::Interaction do
+  describe '#convert' do
+    let(:obj) { double }
+
+    let(:hash) {
+      {
+        'request' => {
+          'uri'    => 'http://google.com',
+          'method' => :get
+        },
+        'response' => {
+          'body' => 'test body'
+        },
+        'recorded_at' => Time.now.httpdate
+      }
+    }
+
+    subject { described_class.new(obj).convert }
+
+    before do
+      allow(Whisperer::Convertors::Hash).to receive(:convert).and_return(hash)
+    end
+
+    it 'converts the given record to hash' do
+      expect(Whisperer::Convertors::Hash).to receive(:convert).with(obj).and_return(hash)
+
+      subject
+    end
+
+    context 'returns the VCR interraction object' do
+      it 'has a proper url' do
+        expect(subject.request.uri).to eq(hash['request']['uri'])
+      end
+
+      it 'has a proper HTTP method' do
+        expect(subject.request.method).to eq(hash['request']['method'])
+      end
+
+      it 'has a proper response body' do
+        expect(subject.response.body).to eq(hash['response']['body'])
+      end
+    end
+  end
+end

data/spec/unit/dsl/base_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Whisperer::BaseDsl do
+  context 'class method' do
+    describe '.link_dsl' do
+      before :all do
+        described_class.link_dsl('headers')
+      end
+
+      context 'using of the generated method for accessing sub DSL' do
+        let(:headers_container) { double('headers container') }
+
+        let(:container) do
+          double(
+            'container',
+            headers: headers_container
+          )
+        end
+
+        let(:headers) { double('Whisperer::Dsl::Headers') }
+
+        subject { described_class.new(container) }
+
+        before do
+          allow(Whisperer::Dsl::Headers).to receive(:new).and_return(headers)
+        end
+
+        it 'initializes the header dsl object' do
+          expect(Whisperer::Dsl::Headers).to receive(:new).with(headers_container)
+
+          subject.headers {}
+        end
+
+        it 'executes a given block over the header dsl object' do
+          expect(headers).to receive(:accept).with('test')
+
+          subject.headers {
+            accept 'test'
+          }
+        end
+      end
+    end
+
+    describe '.build' do
+      context 'when there is a linked container class' do
+        let(:request) { instance_double('Whisperer::Request') }
+
+        before do
+          described_class.link_container_class(Whisperer::Request)
+
+          allow(Whisperer::Request).to receive(:new).and_return(request)
+        end
+
+        it 'initializes a new instance of an object for keeping data' do
+          expect(Whisperer::Request).to receive(:new)
+
+          described_class.build
+        end
+
+        it 'initializes a new instance of the dsl' do
+          expect(described_class).to receive(:new).with(request)
+
+          described_class.build
+        end
+      end
+
+      context 'when there is not a linked container class' do
+        before do
+          described_class.instance_variable_set(:@container_class, nil)
+        end
+
+        it 'raises an error' do
+          expect { described_class.build }.to raise_error(
+            ArgumentError,
+            'You should associate a container (model) with this dsl class, before building it'
+          )
+        end
+      end
+    end
+
+    describe '.add_writer' do
+      context 'using of the generated method for writing data to the container' do
+        let(:container) { double }
+
+        before :all do
+          described_class.add_writer('some_attr')
+        end
+
+        subject { described_class.new(container) }
+
+        it 'writes a given value to the container' do
+          expect(container).to receive("some_attr=").with('my value')
+
+          subject.some_attr('my value')
+        end
+      end
+    end
+  end
+end

data/spec/unit/dsl/body_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+TestUser = Class.new(OpenStruct)
+
+FactoryGirl.define do
+  factory :john_snow, class: TestUser do
+    name 'John Snow'
+  end
+
+  factory :eddard_stark, class: TestUser do
+    name 'Eddard Stark'
+  end
+end
+
+describe Whisperer::Dsl::Body do
+  let(:serialized_data) { 'serialized data' }
+  let(:container)       { instance_double('Whisperer::Body', :string= => true) }
+  let(:serializer)      { double('Serialize', serialize: true) }
+
+  subject { described_class.new(container) }
+
+  before do
+    allow(Whisperer).to receive(:serializer).and_return(serializer)
+    allow(serializer).to receive(:serialize).and_return(serialized_data)
+  end
+
+  describe '#factory' do
+    it 'writes a factory' do
+      expect(subject).to receive(:raw_data) do |model|
+        expect(model.name).to eq('John Snow')
+      end
+
+      subject.factory(:john_snow)
+    end
+  end
+
+  describe '#factories' do
+    it 'writes factories' do
+      expect(subject).to receive(:raw_data) do |model|
+        expect(model.first.name).to eq('John Snow')
+        expect(model.last.name).to eq('Eddard Stark')
+      end
+
+      subject.factories([:john_snow, :eddard_stark])
+    end
+  end
+
+  describe '#raw_data' do
+    let(:container) { instance_double('Whisperer::Body', :data_obj= => true, :serializer_opts= => true) }
+
+    it 'assigns the data object to the container' do
+      expect(container).to receive(:data_obj=).with('test obj')
+
+      subject.raw_data('test obj')
+    end
+
+    it 'assigns the serializer options to the container' do
+      expect(container).to receive(:serializer_opts=).with('test options')
+
+      subject.raw_data(nil, 'test options')
+    end
+  end
+
+  describe '#serializer' do
+    let(:container) { instance_double('Whisperer::Body', :serializer= => true) }
+
+    it 'converts the name to the symbol and assigns to the container' do
+      expect(container).to receive(:serializer=).with(:test_name)
+
+      subject.serializer 'test_name'
+    end
+  end
+end

data/spec/unit/dsl/headers_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Whisperer::Dsl::Headers do
+  let(:container) { Whisperer::Headers.new }
+
+  subject { described_class.new(container) }
+
+  describe '#method_missing' do
+    it 'defines the accept attribute' do
+      subject.accept('text/plain')
+
+      expect(
+        container.respond_to?(:accept)
+      ).to be_truthy
+    end
+
+    it 'assigns the value to the newly defined accept method' do
+      subject.accept('text/plain')
+
+      expect(container.accept).to eq('text/plain')
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'responds to the accept method' do
+      subject.accept('text/plain')
+
+      expect(subject.respond_to?(:accept)).to be_truthy
+    end
+  end
+end

data/spec/unit/dsl/request_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Whisperer::Dsl::Request do
+end

data/spec/unit/dsl/response_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Whisperer::Dsl::Response do
+end

data/spec/unit/dsl/status_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Whisperer::Dsl::Status do
+end

data/spec/unit/dsl_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Whisperer::Dsl do
+end

data/spec/unit/generator_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Whisperer::Generator do
+  let(:record) { double(sub_path: 'test') }
+
+  let(:hash) {
+    {
+      'request' => {
+        'uri'    => 'http://google.com',
+        'method' => :get
+      },
+      'response' => {
+        'body' => 'test body'
+      },
+      'recorded_at' => Time.now.httpdate
+    }
+  }
+
+  let(:interraction) do
+    VCR::HTTPInteraction.from_hash(hash)
+  end
+
+  describe '#generate' do
+    let(:path_to_cassette_dir) { VCR.configuration.cassette_library_dir + '/test/' }
+    let(:path_to_cassette)     { path_to_cassette_dir + 'testcassette.yml' }
+
+    subject { described_class.new(record, 'testcassette') }
+
+    before do
+      allow(Whisperer::Preprocessors).to receive(:process!).and_return(record)
+      allow(Whisperer::Convertors::Interaction).to receive(:convert).and_return(interraction)
+    end
+
+    after do
+      File.delete(path_to_cassette)
+      Dir.delete(path_to_cassette_dir)
+    end
+
+    it 'processes preprocessors' do
+      expect(Whisperer::Preprocessors).to receive(:process!).with(record)
+
+      subject.generate
+    end
+
+    it 'converts the record into VCR http interraction object' do
+      expect(Whisperer::Convertors::Interaction).to receive(:convert).with(record).and_return(interraction)
+
+      subject.generate
+    end
+
+    it 'generates a VCR cassette' do
+      subject.generate
+
+      expect(
+        File.exists?(path_to_cassette)
+      ).to be_truthy
+    end
+
+    it 'returns a generated cassette' do
+      subject.generate
+
+      expect(subject.generate).to match(/http_interactions:/)
+    end
+
+    it 'removes the duplication' do
+      Dir.mkdir(path_to_cassette_dir)
+
+      f = File.open(path_to_cassette, 'w')
+      f.write('mytest')
+      f.close
+
+      subject.generate
+
+      expect(subject.generate).to_not match(/mytest/)
+    end
+  end
+end

data/spec/unit/helpers_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+FakeClass = Class.new do
+  def process; end
+end
+
+describe Whisperer::Helpers do
+  describe '.add_builder' do
+    let(:obj) { 'some simple object' }
+
+    let(:faker) {
+      instance_double('FakeClass', process: true)
+    }
+
+    before(:all) do
+      FakeClass.extend(Whisperer::Helpers)
+      FakeClass.add_builder(:process)
+    end
+
+    before do
+      allow(FakeClass).to receive(:new).and_return(faker)
+    end
+
+    subject { FakeClass.process(obj) }
+
+    it 'initializes the fake object' do
+      expect(FakeClass).to receive(:new).with(obj)
+
+      subject
+    end
+
+    it 'serializes an object' do
+      expect(faker).to receive(:process)
+
+      subject
+    end
+  end
+end