clarify 1.1.1 → 2.0.0.alpha.1

data/spec/clarify/collection_iterator_spec.rb

@@ -0,0 +1,86 @@
+
+describe Clarify::CollectionIterator do
+  describe '#collections' do
+    let(:coll1) { double(:collection1, next: 2, more?: true) }
+    let(:coll2) { double(:collection2, next: 3, more?: true) }
+    let(:coll3) { double(:collection2, more?: false) }
+
+    let(:restclient) do
+      restclient = double(:restclient)
+      allow(restclient).to receive(:get).with(any_args)
+        .and_return(coll1, coll2, coll3)
+
+      restclient
+    end
+    let(:iterator) do
+      Clarify::CollectionIterator.new(restclient, restclient.get(1))
+    end
+
+    it 'iterates over all three collections' do
+      expect(iterator.collections.to_a).to eq([coll1, coll2, coll3])
+    end
+  end
+
+  describe '#each' do
+    let(:coll1) do
+      c = double(:collection1, next: 2, more?: true)
+      allow(c).to receive(:each).once.and_yield(1).and_yield(2).and_yield(3)
+      c
+    end
+    let(:coll2) do
+      c = double(:collection2, next: 3, more?: true)
+      allow(c).to receive(:each).once.and_yield(4).and_yield(5).and_yield(6)
+      c
+    end
+    let(:coll3) do
+      c = double(:collection3, more?: false)
+      allow(c).to receive(:each).once.and_yield(7).and_yield(8).and_yield(9)
+      c
+    end
+
+    let(:restclient) do
+      restclient = double(:restclient)
+      allow(restclient).to receive(:get).with(any_args)
+        .and_return(coll1, coll2, coll3)
+
+      restclient
+    end
+    let(:iterator) do
+      Clarify::CollectionIterator.new(restclient, restclient.get(1))
+    end
+
+    it 'iterates over all the elements inside each collection' do
+      expect(iterator.to_a).to eq([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    end
+  end
+
+  context 'with search results which yield two variables' do
+    describe '#each' do
+      let(:coll1) do
+        c = double(:collection1, next: 2, more?: true)
+        allow(c).to receive(:each).once.and_yield(1, 2).and_yield(3, 4)
+        c
+      end
+      let(:coll2) do
+        c = double(:collection2, more?: false)
+        allow(c).to receive(:each).once.and_yield(5, 6).and_yield(7, 8)
+        c
+      end
+
+      let(:restclient) do
+        restclient = double(:restclient)
+        allow(restclient).to receive(:get).with(any_args)
+          .and_return(coll1, coll2)
+
+        restclient
+      end
+      let(:iterator) do
+        Clarify::CollectionIterator.new(restclient, restclient.get(1))
+      end
+
+      it 'iterates over all the elements inside each collection' do
+        expect(iterator.to_a).to eq([[1, 2], [3, 4], [5, 6], [7, 8]])
+      end
+    end
+  end
+end

data/spec/clarify/configuration_spec.rb

@@ -0,0 +1,77 @@
+
+describe Clarify::Configuration do
+  let(:api_key) { double(:api_key) }
+  let(:server) { 'https://example.com/' }
+  let(:configuration) do
+    Clarify::Configuration.new(api_key: api_key, server: server)
+  end
+
+  describe '#api_key?' do
+    subject { configuration.api_key? }
+    context 'when the api key is nil' do
+      let(:api_key) { nil }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'when the api key is empty' do
+      let(:api_key) { '' }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'when the api key is correctly entered' do
+      let(:api_key) { 'abc123' }
+      it { is_expected.to eq(true) }
+    end
+  end
+
+  describe '#ssl?' do
+    subject { configuration.ssl? }
+    context 'the URL has https specified' do
+      let(:server) { 'https://example.com' }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'the URL has http specified' do
+      let(:server) { 'http://example.com' }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'the URL has nothing specified' do
+      let(:server) { 'example.com' }
+      it { is_expected.to eq(false) }
+    end
+  end
+
+  describe '#host' do
+    subject { configuration.host }
+    it { is_expected.to eq('example.com') }
+  end
+
+  describe '#port' do
+    subject { configuration.port }
+
+    context 'with https' do
+      context 'with a custom port' do
+        let(:server) { 'https://example.com:444' }
+        it { is_expected.to eq(444) }
+      end
+
+      context 'without a custom port' do
+        let(:server) { 'https://example.com' }
+        it { is_expected.to eq(443) }
+      end
+    end
+
+    context 'with http' do
+      context 'with a custom port' do
+        let(:server) { 'http://example.com:8080' }
+        it { is_expected.to eq(8080) }
+      end
+
+      context 'without a custom port' do
+        let(:server) { 'http://example.com' }
+        it { is_expected.to eq(80) }
+      end
+    end
+  end
+end

data/spec/clarify/errors_spec.rb

@@ -0,0 +1,15 @@
+
+describe Clarify::UnrecognizedResponseError do
+  let(:response) { 'SomeFutureDataType' }
+  let(:error) do
+    begin
+      fail Clarify::UnrecognizedResponseError, response
+    rescue Clarify::UnrecognizedResponseError => e
+      e
+    end
+  end
+
+  it 'allows access to the failing response' do
+    expect(error.to_s).to eq 'Unrecognized response class SomeFutureDataType'
+  end
+end

data/spec/clarify/response_factory_spec.rb

@@ -0,0 +1,51 @@
+
+describe Clarify::ResponseFactory do
+  let(:factory) { Clarify::ResponseFactory.new }
+
+  describe '#make_result' do
+    context 'the server sent a Collection type' do
+      it 'returns a Clarify::Responses::Collection' do
+        response = double(:response,
+                          body: '{"_class": "Collection"}',
+                          code: '200'
+                         )
+
+        result = factory.make_result(response)
+        expect(result).to be_a(Clarify::Responses::Collection)
+      end
+    end
+
+    context 'the server sent an unrecognized type' do
+      it 'raises an UnrecognizedResponseError' do
+        response = double(:response, body: '{"_class": "FooBarClass"}')
+        allow(factory).to receive(:raise_on_code!)
+
+        expect { factory.make_result(response) }.to raise_error(
+          Clarify::UnrecognizedResponseError,
+          'Unrecognized response class FooBarClass')
+      end
+    end
+
+    context 'the response has no body' do
+      let(:response) do
+        double(:response, code: 204, body: nil)
+      end
+      subject { factory.make_result(response) }
+      it { is_expected.to be_a(Clarify::Responses::NoBody) }
+    end
+  end
+
+  describe '#raise_on_code!' do
+    it 'does nothing on a 200' do
+      response = double(:response, code: '200')
+      expect(factory.raise_on_code!(response)).to eq(nil)
+    end
+
+    it 'raises UnauthenticatedError on 401' do
+      response = double(:response, code: '401')
+      expect { factory.raise_on_code!(response) }.to raise_error(
+        Clarify::UnauthenticatedError
+      )
+    end
+  end
+end

data/spec/clarify/response_spec.rb

@@ -0,0 +1,69 @@
+
+describe Clarify::Response do
+  describe '#http_status_code' do
+    it 'returns the int version of the response status code' do
+      response = Clarify::Response.new(nil, double(:response, code: '201'))
+
+      expect(response.http_status_code).to eq(201)
+    end
+  end
+
+  describe '#relation!' do
+    context 'with a present relation' do
+      let(:body) { { '_links' => { 'self' => { 'href' => 'my-url' } } } }
+      it 'returns the value from the relation' do
+        expect(Clarify::Response.new(body, nil).relation!('self'))
+          .to eq('my-url')
+      end
+    end
+
+    context 'without a relation present' do
+      let(:body) { {} }
+      it 'raises an error' do
+        expect do
+          Clarify::Response.new(body, nil).relation!('self')
+        end.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '#relation' do
+    it 'returns a href for a single value relation' do
+      body = {
+        '_links' => {
+          'test_value' => {
+            'href' => 'http://example.com'
+          }
+        }
+      }
+      response = Clarify::Response.new(body, nil)
+
+      expect(response.relation('test_value')).to eq('http://example.com')
+    end
+
+    context 'with a single element' do
+      subject do
+        Clarify::Responses::Collection.new(track_data, nil).relation('next')
+      end
+
+      context 'with a next url' do
+        let(:track_data) do
+          { '_links' => { 'next' => { 'href' => 'my-url' } } }
+        end
+        it { is_expected.to eq('my-url') }
+      end
+
+      context 'with no next url' do
+        let(:track_data) do
+          { '_links' => { 'prev' => { 'href' => 'my-url' } } }
+        end
+        it { is_expected.to eq(nil) }
+      end
+
+      context 'with no _links at all' do
+        let(:track_data) { {} }
+        it { is_expected.to eq(nil) }
+      end
+    end
+  end
+end

data/spec/clarify/responses/bundle_spec.rb

@@ -0,0 +1,8 @@
+
+describe Clarify::Responses::Bundle do
+  describe '#name' do
+    let(:body) { { 'name' => 'foobar' } }
+    subject { Clarify::Responses::Bundle.new(body, nil).name }
+    it { is_expected.to eq('foobar') }
+  end
+end

data/spec/clarify/responses/collection_spec.rb

@@ -0,0 +1,58 @@
+
+describe Clarify::Responses::Collection do
+  it 'iterates over each bundle' do
+    track_data = {
+      '_links' => {
+        'items' => [
+          {
+            'href' => 'a'
+          },
+          {
+            'href' => 'b'
+          }
+        ]
+      }
+    }
+    response = Clarify::Responses::Collection.new(track_data, nil)
+    expect { |b| response.each(&b) }.to yield_control.twice
+    expect(response.to_a).to eq %w(a b)
+  end
+
+  describe '#next' do
+    subject { Clarify::Responses::Collection.new(track_data, nil).next }
+
+    context 'with a next url' do
+      let(:track_data) { { '_links' => { 'next' => { 'href' => 'my-url' } } } }
+      it { is_expected.to eq('my-url') }
+    end
+
+    context 'with no next url' do
+      let(:track_data) { { '_links' => { 'prev' => { 'href' => 'my-url' } } } }
+      it { is_expected.to eq(nil) }
+    end
+
+    context 'with no _links at all' do
+      let(:track_data) { {} }
+      it { is_expected.to eq(nil) }
+    end
+  end
+
+  describe '#more?' do
+    subject { Clarify::Responses::Collection.new(track_data, nil).more? }
+
+    context 'with a next url' do
+      let(:track_data) { { '_links' => { 'next' => { 'href' => 'my-url' } } } }
+      it { is_expected.to eq(true) }
+    end
+
+    context 'with no next url' do
+      let(:track_data) { { '_links' => { 'prev' => { 'href' => 'my-url' } } } }
+      it { is_expected.to eq(false) }
+    end
+
+    context 'with no _links at all' do
+      let(:track_data) { {} }
+      it { is_expected.to eq(false) }
+    end
+  end
+end

data/spec/clarify/responses/search_collection_spec.rb

@@ -0,0 +1,40 @@
+
+describe Clarify::Responses::SearchCollection do
+  let(:response) { double(:response) }
+  let(:body) do
+    {
+      'item_results' => [
+        { 'name' => '1_result' },
+        { 'name' => '2_result' }
+      ],
+      '_links' => {
+        'items' => [
+          { 'href' => '1_link' },
+          { 'href' => '2_link' }
+        ]
+      }
+    }
+  end
+  let(:search) { Clarify::Responses::SearchCollection.new(body, response) }
+
+  describe '#items' do
+    it 'returns an array of links and results' do
+      expect(search.items).to eq([
+        [{ 'name' => '1_result' }, { 'href' => '1_link' }],
+        [{ 'name' => '2_result' }, { 'href' => '2_link' }]
+      ])
+    end
+  end
+
+  describe '#each' do
+    it 'yields per result' do
+      expect { |b| search.each(&b) }.to yield_control.twice
+    end
+    it 'yields object, ul' do
+      expect(search.to_a).to eq([
+        [{ 'name' => '1_result' }, '1_link'],
+        [{ 'name' => '2_result' }, '2_link']
+      ])
+    end
+  end
+end

data/spec/clarify/responses/tracks_spec.rb

@@ -0,0 +1,18 @@
+
+describe Clarify::Responses::Tracks do
+  it 'iterates over each track' do
+    track_data = {
+      'tracks' => [
+        {
+          'media_url' => 'a'
+        },
+        {
+          'media_url' => 'b'
+        }
+      ]
+    }
+    response = Clarify::Responses::Tracks.new(track_data, nil)
+    expect { |b| response.each(&b) }.to yield_control.twice
+    expect(response.map { |t| t['media_url'] }).to eq %w(a b)
+  end
+end

data/spec/clarify/rest_client_spec.rb

@@ -0,0 +1,222 @@
+
+describe Clarify::RestClient do
+  let(:config) { double(:configuration) }
+  let(:restclient) { Clarify::RestClient.new(config) }
+
+  describe '#get' do
+    it 'creates a get_request and passes it to request' do
+      request = double(:request)
+      response = double(:response)
+
+      expect(restclient).to receive(:get_request)
+        .with('/hi', {}).and_return(request)
+      expect(restclient).to receive(:request)
+        .with(request).and_return(response)
+      expect(restclient.get('/hi')).to eq(response)
+    end
+  end
+
+  describe '#get_request' do
+    subject { restclient.get_request('/bundle/abc123', a: :b) }
+    it 'creates a Get request' do
+      expect(restclient).to receive(:make_get_url)
+        .with('/bundle/abc123', a: :b).and_return('/bundle/abc123?a=b')
+
+      expect(subject).to be_a(Net::HTTP::Get)
+      expect(subject.path).to eq('/bundle/abc123?a=b')
+    end
+  end
+
+  describe '#make_get_url' do
+    subject { restclient.make_get_url(url, params) }
+    context 'with no URL parameters on the input url' do
+      let(:url) { '/bundle/abc123' }
+
+      context 'with no query parameters' do
+        let(:params) { {} }
+
+        it { is_expected.to eq('/bundle/abc123') }
+      end
+
+      context 'with a few query parameters' do
+        let(:params) { { a: :b } }
+
+        it { is_expected.to eq('/bundle/abc123?a=b') }
+      end
+    end
+
+    context 'with URL parameters on the input url' do
+      let(:url) { '/bundle/abc123?a=b' }
+
+      context 'with no query parameters' do
+        let(:params) { {} }
+
+        it { is_expected.to eq('/bundle/abc123?a=b') }
+      end
+
+      context 'with a few query parameters' do
+        let(:params) { { c: :d } }
+
+        it { is_expected.to eq('/bundle/abc123?a=b&c=d') }
+      end
+    end
+  end
+
+  describe '#post' do
+    it 'creates a post_request and passes it to request' do
+      request = double(:request)
+      response = double(:response)
+
+      expect(restclient).to receive(:post_request)
+        .with('/hi', {}).and_return(request)
+      expect(restclient).to receive(:request)
+        .with(request).and_return(response)
+      expect(restclient.post('/hi')).to eq(response)
+    end
+  end
+
+  describe '#post_request' do
+    let(:url) { '/bundle/123' }
+    subject { restclient.post_request(url) }
+    it { is_expected.to be_a(Net::HTTP::Post) }
+
+    context 'with a body' do
+      let(:body) { { 'hi' => 'there' } }
+      subject { restclient.post_request(url, body).body }
+      it { is_expected.to eq('hi=there') }
+    end
+  end
+
+  describe '#put' do
+    it 'creates a put_request and passes it to request' do
+      request = double(:request)
+      response = double(:response)
+
+      expect(restclient).to receive(:put_request)
+        .with('/hi', {}).and_return(request)
+      expect(restclient).to receive(:request)
+        .with(request).and_return(response)
+      expect(restclient.put('/hi')).to eq(response)
+    end
+  end
+
+  describe '#put_request' do
+    let(:url) { '/bundle/123' }
+    subject { restclient.put_request(url) }
+    it { is_expected.to be_a(Net::HTTP::Put) }
+
+    context 'with a body' do
+      let(:body) { { 'hi' => 'there' } }
+      subject { restclient.put_request(url, body).body }
+      it { is_expected.to eq('hi=there') }
+    end
+  end
+
+  describe '#delete' do
+    it 'creates a delete_request and passes it to request' do
+      request = double(:request)
+      response = double(:response)
+
+      expect(restclient).to receive(:delete_request)
+        .with('/hi', {}).and_return(request)
+      expect(restclient).to receive(:request)
+        .with(request).and_return(response)
+      expect(restclient.delete('/hi')).to eq(response)
+    end
+  end
+
+  describe '#delete_request' do
+    let(:url) { '/bundle/123' }
+    subject { restclient.delete_request(url) }
+    it { is_expected.to be_a(Net::HTTP::Delete) }
+  end
+
+  describe '#request' do
+    let(:connection) { double(:connection) }
+    before(:each) do
+      expect(restclient).to receive(:connection).and_return(connection)
+    end
+
+    it 'pipelines data through blessing, then execution, then result' do
+      in_req = double(:request)
+
+      blessed = double(:blessed)
+      expect(restclient).to receive(:bless_request)
+        .with(in_req).and_return(blessed)
+
+      raw_result = double(:raw_result)
+      expect(connection).to receive(:request).with(blessed)
+        .and_return(raw_result)
+
+      out_result = double(:result)
+      expect(restclient).to receive(:make_result).and_return(out_result)
+
+      expect(restclient.request(in_req)).to eq(out_result)
+    end
+  end
+
+  describe '#bless_request' do
+    subject { restclient.bless_request({}) }
+    before(:each) { allow(restclient).to receive(:user_agent).and_return 'UA' }
+
+    context 'with no API key' do
+      let(:config) { double(:config, api_key?: false) }
+      it { is_expected.to eq('User-Agent' => 'UA') }
+    end
+
+    context 'with an API key' do
+      let(:config) { double(:config, api_key?: true, api_key: 'abc123') }
+      it do
+        headers = {
+          'User-Agent' => 'UA',
+          'Authorization' => 'Bearer abc123'
+        }
+        is_expected.to eq(headers)
+      end
+    end
+  end
+
+  describe '#user_agent' do
+    subject { restclient.user_agent }
+    it do
+      ruby_id = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+
+      expect(subject).to eq("clarify-ruby/#{Clarify::VERSION}/#{ruby_id}")
+    end
+  end
+
+  describe '#make_result' do
+    it 'passes the response to the factory' do
+      raw_response = double(:raw_response)
+      response = double(:response)
+      factory = double(:factory)
+      expect(factory).to receive(:make_result).with(raw_response)
+        .and_return(response)
+      expect(restclient).to receive(:response_factory).and_return(factory)
+
+      expect(restclient.make_result(raw_response)).to eq(response)
+    end
+  end
+
+  describe '#response_factory' do
+    it 'returns a ResponseFactory' do
+      expect(restclient.response_factory).to be_a(Clarify::ResponseFactory)
+    end
+  end
+
+  describe '#connection' do
+    let(:config) { double(:config, host: 'abc', port: 123, ssl?: true) }
+    it 'uses configuration options to generate the connection' do
+      expect(restclient.connection.address).to eq('abc')
+      expect(restclient.connection.port).to eq(123)
+      expect(restclient.connection.use_ssl?).to eq(true)
+    end
+
+    context 'without ssl' do
+      let(:config) { double(:config, host: 'abc', port: 123, ssl?: false) }
+      it 'uses configuration options to generate the connection' do
+        expect(restclient.connection.use_ssl?).to eq(false)
+      end
+    end
+  end
+end