wcc-data 0.3.3 → 0.3.7

data/spec/wcc/data/faraday_client_app_token_auth_spec.rb

@@ -1,237 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe WCC::Data::FaradayClientAppTokenAuth do
-  let(:app) { spy(:application) }
-
-  describe WCC::Data::FaradayClientAppTokenAuth::RedisCache do
-    let(:connection) { instance_spy(Redis) }
-    let(:connection_lambda) { -> (&blk) { blk.call(connection) } }
-
-    describe "#initialize" do
-      it "requires a callable for Redis connection" do
-        expect { described_class.new }.to raise_error(ArgumentError)
-        obj = described_class.new(connection_lambda)
-        expect(obj.connection).to eq(connection_lambda)
-      end
-
-      it "allows setting a :cache_key option to change the token store" do
-        obj = described_class.new(connection_lambda, cache_key: "store")
-        expect(obj.cache_key).to eq("store")
-      end
-
-      it "defaults to the value of the DEFAULT_CACHE_KEY constant" do
-        obj = described_class.new(connection_lambda)
-        expect(obj.cache_key).to eq(described_class::DEFAULT_CACHE_KEY)
-      end
-    end
-
-    describe "#[]" do
-      subject(:cache) { described_class.new(connection_lambda) }
-
-      it "returns HGET on the cache_key for the specified field" do
-        expect(connection)
-          .to receive(:hget).with(cache.cache_key, "example.com").and_return("123abc")
-        expect(cache["example.com"]).to eq("123abc")
-      end
-    end
-
-    describe "#[]=" do
-      subject(:cache) { described_class.new(connection_lambda) }
-
-      it "does HSET on the cache_key for the specified field and value" do
-        cache["example.com"] = "abc123"
-        expect(connection)
-          .to have_received(:hset).with(cache.cache_key, "example.com", "abc123")
-      end
-
-      context "with a nil value" do
-        it "does HDEL on the cache_key for the specified field" do
-          cache["example.com"] = nil
-          expect(connection)
-            .to have_received(:hdel).with(cache.cache_key, "example.com")
-        end
-      end
-    end
-  end
-
-  describe "#initialize" do
-    it "takes an app as param one and sets to @app" do
-      obj = described_class.new(:app)
-      expect(obj.send(:instance_variable_get, :@app)).to eq(:app)
-    end
-
-    it "takes a :cache option" do
-      obj = described_class.new(:app, cache: :cache)
-      expect(obj.cache).to eq(:cache)
-    end
-
-    it "takes a :token_factory option" do
-      obj = described_class.new(:app, token_factory: :factory)
-      expect(obj.token_factory).to eq(:factory)
-    end
-
-    it "defaults :cache option to an instance of RedisCache" do
-      obj = described_class.new(:app)
-      expect(obj.cache).to be_a(described_class::RedisCache)
-      expect(obj.cache.connection).to eq(Sidekiq.method(:redis))
-    end
-
-    it "defaults :token_factory option to a callable" do
-      obj = described_class.new(:app)
-      expect(obj.token_factory).to respond_to(:call)
-    end
-
-    describe "default token_factory" do
-      it "returns #token property from a Nucleus::ClientAppToken create" do
-        token = instance_spy(WCC::Data::Nucleus::ClientAppToken)
-
-        expect(WCC::Data::Nucleus::ClientAppToken)
-          .to receive(:create).with(hostname: "example.com").and_return(token)
-        expect(token).to receive(:token).and_return("abc123")
-        expect(described_class.new(:app).token_factory.("example.com"))
-          .to eq("abc123")
-      end
-    end
-  end
-
-  describe "#call" do
-    let(:app) { spy(:application) }
-    subject(:auth) { described_class.new(app) }
-    let(:env) {
-      {
-        url: URI("http://example.com"),
-        request_headers: {},
-      }
-    }
-
-    before do
-      allow(auth)
-        .to receive(:token_for).with("example.com").and_return("abc123")
-    end
-
-    it "sets env's Authorization header using value from #token_for" do
-      auth.call(env)
-      expect(env[:request_headers]["Authorization"])
-        .to eq("Bearer abc123")
-    end
-
-    it "calls @app with env" do
-      expect(app).to receive(:call).with(env)
-      auth.call(env)
-    end
-
-    it "adds an on_complete handler to @app" do
-      allow(app).to receive(:call).and_return(app).ordered
-      expect(app).to receive(:on_complete).ordered
-      auth.call(env)
-    end
-
-    describe "on_complete handler" do
-      subject(:auth) { described_class.new(app, cache: cache) }
-      let(:cache) { instance_spy(described_class::RedisCache) }
-      let(:handler) {
-        handler = nil
-        allow(app).to receive(:call).and_return(app)
-        allow(app).to receive(:on_complete) { |&block| handler = block }
-
-        auth.call(env)
-
-        handler
-      }
-
-      it "removes value from cache when response is unsuccessful" do
-        expect(cache).to receive(:[]=).with("example.com", nil).exactly(2).times
-        handler.(status: 200)
-        handler.(status: 400)
-        handler.(status: 500)
-      end
-
-      it "retries the request after clearing the cache on a 403 response" do
-        expect(app).to receive(:call).with(env).ordered
-        expect(cache).to receive(:[]=).with("example.com", nil).ordered
-        expect(app).to receive(:call).with(env).ordered
-        handler.(status: 403)
-      end
-    end
-
-    class FakeApp
-      attr_accessor :response
-      def initialize(response)
-        @response = response
-      end
-      def call(request)
-        @request = request
-        self
-      end
-      def on_complete
-        @request[:body] = "response"
-        yield(response)
-      end
-    end
-
-    describe "multiple 403 errors" do
-      subject(:auth) { described_class.new(app, cache: cache, token_factory: -> (_) { "value" }) }
-      let(:cache) { instance_spy(described_class::RedisCache) }
-      let(:app) { FakeApp.new(body: "response", status: 403) }
-
-      it "doesn't retry forever" do
-        auth.call(env)
-      end
-
-      it "resets the body to original request body" do
-        expect(app).to receive(:call).with(hash_including(body: "request")).twice.and_call_original
-        auth.call(env.merge(body: "request"))
-      end
-    end
-  end
-
-  describe "#token_for" do
-    let(:cache) { instance_spy(described_class::RedisCache) }
-    subject(:auth) { described_class.new(:app, cache: cache) }
-
-    context "when cache is non-nil" do
-      before do
-        allow(cache).to receive(:[]).with("example.com").and_return("abc123")
-      end
-
-      it "returns value from cache" do
-        expect(auth.token_for("example.com")).to eq("abc123")
-      end
-
-      it "does not call @token_factory" do
-        expect(auth.token_factory).to_not receive(:call)
-        auth.token_for("example.com")
-      end
-    end
-
-    context "when cache is empty" do
-      before do
-        allow(cache).to receive(:[]).and_return(nil)
-        allow(auth.token_factory)
-          .to receive(:call).with("example.com").and_return("abc123")
-      end
-
-      it "calls @token_factory with passed host" do
-        expect(auth.token_for("example.com")).to eq("abc123")
-      end
-
-      it "stores the value in the cache" do
-        expect(cache).to receive(:[]=).with("example.com", "abc123")
-        auth.token_for("example.com")
-      end
-
-      it "passes error up the chain when service unavailable" do
-        allow(auth.token_factory)
-          .to receive(:call)
-          .and_raise(WCC::Data::Mapper::ServiceUnavailable)
-  
-        expect {
-          auth.call({
-            url: URI("http://example.com"),
-            request_headers: {},
-          })
-        }.to raise_error(WCC::Data::Mapper::ServiceUnavailable)
-      end
-    end
-  end
-end

data/spec/wcc/data/mapper/attributes_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Mapper::Attributes do
-  let(:klass) {
-    Class.new do
-      include WCC::Data::Mapper::Attributes
-    end
-  }
-
-  describe "::attribute" do
-    subject { klass }
-    it_behaves_like :inheritable_class_attributes, :attributes
-
-    it "takes a name and optional options and stores them in ::attributes" do
-      subject.attribute :name, foo: :bar
-      expect(subject.attributes).to eq("name" => { foo: :bar })
-    end
-
-    it "freezes the options hash" do
-      subject.attribute :name
-      expect { subject.attributes["name"][:foo] = "foo" }.to raise_error(RuntimeError)
-    end
-
-    it "defines an instance method by the same name" do
-      expect(subject.new).to_not respond_to(:name)
-      subject.attribute :name
-      expect(subject.new).to respond_to(:name)
-    end
-
-    context "defined instance method" do
-      it "returns the value set on the instance for this attribute" do
-        subject.attribute :name
-        obj = subject.new("name" => "foo")
-        expect(obj.name).to eq("foo")
-      end
-    end
-
-    context "with writer option" do
-      it "defines a writer instance method" do
-        subject.attribute :name, writer: true
-        obj = subject.new("name" => "foo")
-        obj.name = "bar"
-        expect(obj.name).to eq("bar")
-      end
-    end
-  end
-
-  describe "#initialize" do
-    subject { klass }
-
-    it "takes a hash of attributes and sets it to @attributes" do
-      obj = subject.new(foo: :bar)
-      expect(obj.attributes).to eq(foo: :bar)
-    end
-  end
-
-  describe "#[]" do
-    before(:each) do
-      klass.attribute :name
-    end
-    subject { klass.new("name" => "foo", "other" => :value) }
-
-    it "returns raw values of defined attributes" do
-      expect(subject[:name]).to eq("foo")
-      expect(subject["name"]).to eq("foo")
-    end
-
-    it "returns a key error for undefined attributes" do
-      expect { subject[:other] }.to raise_error(KeyError)
-    end
-  end
-
-  describe "#[]=" do
-    before(:each) do
-      klass.attribute :name
-    end
-    subject { klass.new("name" => "foo", "other" => :value) }
-
-    it "sets raw values of defined attributes" do
-      subject[:name] = "value1"
-      expect(subject[:name]).to eq("value1")
-    end
-
-    it "allows string values as key" do
-      subject["name"] = "value1"
-      expect(subject[:name]).to eq("value1")
-    end
-
-    it "returns a key error for undefined attributes" do
-      expect { subject[:other] = "value" }.to raise_error(KeyError)
-    end
-  end
-
-end

data/spec/wcc/data/mapper/json_response_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Mapper::JSONResponse do
-  let(:klass) {
-    Class.new do
-      extend WCC::Data::Mapper::JSONResponse
-
-      attr_accessor :val
-      def initialize(val=nil) @val = val end
-    end
-  }
-
-  describe "::new_from_response" do
-    let(:singular_response) {
-      double(json: { key: "value" }, status: 200)
-    }
-    let(:plural_response) {
-      double(json: [
-        { name: "abc" },
-        { name: "def" },
-      ], status: 200)
-    }
-
-    it "returns a new instance from singular response" do
-      obj = klass.new_from_response(singular_response)
-      expect(obj).to be_a(klass)
-      expect(obj.val).to eq(singular_response.json)
-    end
-
-    it "returns array of instances from array response" do
-      obj = klass.new_from_response(plural_response)
-      expect(obj).to be_a(Array)
-      expect(obj[0].val).to eq(plural_response.json[0])
-      expect(obj[1].val).to eq(plural_response.json[1])
-    end
-
-    it "raises RecordNotFound when response status is 404" do
-      allow(singular_response).to receive(:status).and_return(404)
-      expect { klass.new_from_response(singular_response) }
-        .to raise_error(WCC::Data::Mapper::RecordNotFound)
-
-    end
-
-    it "raises ServiceUnavailable when response status is 503" do
-      allow(singular_response).to receive(:status).and_return(503)
-      expect { klass.new_from_response(singular_response) }
-        .to raise_error(WCC::Data::Mapper::ServiceUnavailable)
-
-    end
-
-    it "raises InvalidResponse error for non-json objects" do
-      expect { klass.new_from_response(double(json: 1, status: 200)) }
-        .to raise_error(WCC::Data::Mapper::InvalidResponse)
-    end
-  end
-
-end

data/spec/wcc/data/mapper/rest_configuration_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Mapper::RESTConfiguration do
-  let(:klass) {
-    Class.new.tap do |klass|
-      klass.extend described_class
-    end
-  }
-  subject { klass }
-  before(:each) do
-    WCC::Data.config.applications[:rest_configuration_test].uri = "http://test.app/"
-    subject.set_endpoint(:rest_configuration_test, "bar/")
-  end
-  after(:each) do
-    WCC::Data.config.applications.delete(:rest_configuration_test)
-  end
-
-  describe "::set_endpoint" do
-    it_behaves_like :inheritable_class_attributes, :endpoint_config
-
-    it "sets @endpoint_config hash with values from args" do
-      expect(subject.endpoint_config).to eq(app: :rest_configuration_test, uri: "bar/")
-    end
-  end
-
-  describe "::endpoint" do
-    it "returns instance of RESTEndpoint" do
-      expect(subject.endpoint).to be_a(WCC::Data::RESTEndpoint)
-    end
-
-    it "sets service using appname and provided URI string" do
-      expect(subject.endpoint.service.uri).to eq(URI("http://test.app/bar/"))
-    end
-  end
-
-  context "lazy configuration" do
-    it "sets endpoint data only when endpoint is called" do
-      WCC::Data.config.applications[:rest_configuration_test].uri = "http://new.test.app/"
-      expect(subject.endpoint.service.uri).to eq(URI("http://new.test.app/bar/"))
-    end
-  end
-
-end

data/spec/wcc/data/mapper/rest_query_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Mapper::RESTQuery do
-  let(:klass) {
-    Class.new.tap do |klass|
-      klass.extend described_class
-    end
-  }
-
-  let(:endpoint) { double(:endpoint) }
-  before(:each) do
-    allow(klass).to receive(:endpoint) { endpoint }
-  end
-
-  shared_examples_for :handles_undefined_endpoint do |method, args|
-    let(:endpoint) { nil }
-    it "raises an EndpointUndefined exception" do
-      expect { klass.send(method, *args) }.to raise_error(WCC::Data::Mapper::EndpointUndefined)
-    end
-  end
-
-  describe "::find" do
-    it_behaves_like :handles_undefined_endpoint, :find, :id_param
-
-    it "calls show(id) on defined endpoint and builds on response" do
-      expect(endpoint).to receive(:show).with(:id_param).and_return(:response)
-      expect(klass).to receive(:new_from_response).with(:response).and_return(:new_response)
-      expect(klass.find(:id_param)).to eq(:new_response)
-    end
-  end
-
-  describe "::list" do
-    it_behaves_like :handles_undefined_endpoint, :list, :params
-
-    it "calls index(params) on defined endpoint and builds on response" do
-      expect(endpoint).to receive(:index).with(params: :params).and_return(:response)
-      expect(klass).to receive(:new_from_response).with(:response).and_return(:new_response)
-      expect(klass.list(:params)).to eq(:new_response)
-    end
-
-    it "allows calling with no params" do
-      expect(endpoint).to receive(:index).with(params: {})
-      expect(klass).to receive(:new_from_response)
-      klass.list
-    end
-
-  end
-
-end
-