wcc-data 0.1.0

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,50 @@
+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 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,29 @@
+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
+      dallas = described_class[:dallas]
+      expect(dallas).to be_a(described_class)
+      expect(dallas.name).to eq("Dallas")
+    end
+
+    it "defines Fort Worth campus" do
+      dallas = described_class[:ft_worth]
+      expect(dallas).to be_a(described_class)
+      expect(dallas.name).to eq("Fort Worth")
+    end
+
+    it "defines Plano campus" do
+      dallas = described_class[:plano]
+      expect(dallas).to be_a(described_class)
+      expect(dallas.name).to eq("Plano")
+    end
+
+  end
+end

data/spec/wcc/data/rack_client_app_token_auth_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+RSpec.describe WCC::Data::RackClientAppTokenAuth do
+
+  describe WCC::Data::RackClientAppTokenAuth::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 "allows setting the :cache_length" do
+        obj = described_class.new(connection_lambda, cache_length: 5)
+        expect(obj.cache_length).to eq(5)
+      end
+
+      it "defaults :cache_key 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
+
+      it "defaults :cache_length to the value of DEFAULT_CACHE_LENGTH constant" do
+        obj = described_class.new(connection_lambda)
+        expect(obj.cache_length).to eq(described_class::DEFAULT_CACHE_LENGTH)
+      end
+    end
+
+    describe "#<<" do
+      subject(:auth) { described_class.new(connection_lambda, cache_key: "test", cache_length: 123) }
+
+      it "calls SET with @cache_key joined to token by a dot and set to '1'" do
+        auth << "token"
+        expect(connection).to have_received(:set).with("test.token", "1")
+      end
+
+      it "calls EXPIRE with the configured cache length" do
+        auth << "token"
+        expect(connection).to have_received(:expire).with("test.token", 123)
+      end
+    end
+
+    describe "#find" do
+      subject(:auth) { described_class.new(connection_lambda, cache_key: "test") }
+
+      it "returns the value from GET on the joined token key" do
+        expect(connection).to receive(:get).with("test.token").and_return("1")
+        expect(auth.find("token")).to eq("1")
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "takes an app argument and sets to @app" do
+      obj = described_class.new(:app)
+      expect(obj.app).to eq(:app)
+    end
+
+    it "takes a :cache option and sets to @cache" do
+      obj = described_class.new(:app, cache: :cache)
+      expect(obj.cache).to eq(:cache)
+    end
+
+    it "takes a :lookup_token and sets to @lookup_token" do
+      obj = described_class.new(:app, lookup_token: :lookup)
+      expect(obj.lookup_token).to eq(:lookup)
+    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
+
+    describe "default :lookup_token value" do
+      it "tries to fetch a token with the given value" do
+        expect(WCC::Data::Nucleus::ClientAppToken)
+          .to receive(:find).with("abc123").and_return(:val)
+        expect(described_class.new(:app).lookup_token.("abc123"))
+          .to eq(:val)
+      end
+
+      it "returns nil when InvalidResponse raised" do
+        allow(WCC::Data::Nucleus::ClientAppToken)
+          .to receive(:find).and_raise(WCC::Data::Mapper::InvalidResponse)
+        expect(described_class.new(:app).lookup_token.("abc123"))
+          .to be_nil
+      end
+
+      it "returns nil when RecordNotFound raised" do
+        allow(WCC::Data::Nucleus::ClientAppToken)
+          .to receive(:find).and_raise(WCC::Data::Mapper::RecordNotFound)
+        expect(described_class.new(:app).lookup_token.("abc123"))
+          .to be_nil
+      end
+    end
+
+  end
+
+  describe "#find" do
+    let(:cache) { instance_spy(described_class::RedisCache) }
+    subject(:auth) { described_class.new(:app, cache: cache) }
+
+    context "with token in the cache" do
+      before do
+        allow(auth.cache).to receive(:find).with("abc123").and_return("1")
+      end
+
+      it "calls find with token on the cache and then returns cached value" do
+        expect(auth.find("abc123"))
+          .to eq("1")
+      end
+
+      it "does not call lookup_token" do
+        expect(auth.lookup_token).to_not receive(:call)
+        auth.find("abc123")
+      end
+    end
+
+    context "with an empty cache" do
+      before do
+        allow(cache).to receive(:find).and_return(nil)
+      end
+
+      it "calls lookup_token with the token" do
+        expect(auth.lookup_token)
+          .to receive(:call).with("abc123").and_return(true)
+        expect(auth.find("abc123")).to eq(true)
+      end
+
+      context "with a valid token" do
+        before do
+          allow(auth.lookup_token).to receive(:call).and_return(true)
+        end
+
+        it "shovels the value into the cache" do
+          expect(cache).to receive(:<<).with("abc123")
+          auth.find("abc123")
+        end
+
+        it "returns a truthy value" do
+          expect(auth.find("abc123")).to be_truthy
+        end
+      end
+
+      context "with an invalid token" do
+        before do
+          allow(auth.lookup_token).to receive(:call).and_return(false)
+        end
+
+        it "does not shovel value into the cache" do
+          expect(auth.cache).to_not receive(:<<)
+          auth.find("abc123")
+        end
+
+        it "returns a falsey value" do
+          expect(auth.find("abc123")).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe "#call" do
+    subject(:auth) { described_class.new(-> (env) {}, cache: cache) }
+    let(:cache) { instance_spy(described_class::RedisCache) }
+    let(:env) {
+      {
+        "HTTP_AUTHORIZATION" => "Bearer abc123",
+      }
+    }
+
+
+    it "passes the bearer token onto the find method" do
+      expect(auth).to receive(:find).with("abc123")
+      auth.call(env)
+    end
+
+    context "truthy find result" do
+      before do
+        allow(auth).to receive(:find).and_return(true)
+      end
+
+      it "passes the request on to the app" do
+        expect(auth.app).to receive(:call).with(env)
+        auth.call(env)
+      end
+
+      it "returns the value of app" do
+        allow(auth.app).to receive(:call).and_return(:value)
+        expect(auth.call(env)).to eq(:value)
+      end
+    end
+
+    context "falsey find result" do
+      before do
+        allow(auth).to receive(:find).and_return(false)
+      end
+
+      it "does not call app" do
+        expect(auth.app).to_not receive(:call)
+        auth.call(env)
+      end
+
+      it "returns a 403 response" do
+        response = auth.call(env)
+
+        expect(response).to eq([403, {}, '{"error":"Invalid Bearer Token"}'])
+      end
+    end
+  end
+end