wcc-data 0.3.9 → 0.4.0.pre

data/spec/wcc/data/faraday_client_app_token_auth_spec.rb

@@ -0,0 +1,237 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,50 @@
+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
+

data/spec/wcc/data/model_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe WCC::Data::Model do
+
+  describe "inherited behavior" do
+    subject { described_class }
+
+    includes = [
+      WCC::Data::Mapper::Attributes,
+    ]
+
+    extensions = [
+      WCC::Data::Mapper::JSONResponse,
+      WCC::Data::Mapper::RESTConfiguration,
+      WCC::Data::Mapper::RESTQuery,
+    ]
+
+    includes.each do |mod|
+      it "includes #{mod}" do
+        expect(subject.ancestors).to include(mod)
+      end
+    end
+
+    extensions.each do |mod|
+      it "extends #{mod}" do
+        extended_modules = (class << subject; self; end).included_modules
+        expect(extended_modules).to include(mod)
+      end
+    end
+
+  end
+
+end

data/spec/wcc/data/nucleus/campus_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe WCC::Data::Nucleus::Campus do
+  it 'inherits EnumeratedType functionality' do
+    expect(described_class.ancestors).to include(WCC::Data::EnumeratedType)
+  end
+
+  context 'with defined data' do
+    it 'defines Dallas campus' do
+      campus = described_class[:dallas]
+      expect(campus).to be_a(described_class)
+      expect(campus.name).to eq('Dallas')
+    end
+
+    it 'defines Fort Worth campus' do
+      campus = described_class[:ft_worth]
+      expect(campus).to be_a(described_class)
+      expect(campus.name).to eq('Fort Worth')
+    end
+
+    it 'defines Plano campus' do
+      campus = described_class[:plano]
+      expect(campus).to be_a(described_class)
+      expect(campus.name).to eq('Plano')
+    end
+
+    it 'defines Frisco campus' do
+      campus = described_class[:frisco]
+      expect(campus).to be_a(described_class)
+      expect(campus.name).to eq('Frisco')
+      expect(campus.code).to eq('FRS')
+    end
+  end
+end