wcc-data 0.3.0 → 0.3.5

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

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

data/spec/wcc/data/model_spec.rb

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

@@ -1,33 +0,0 @@
-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')
-    end
-  end
-end

data/spec/wcc/data/rack_client_app_token_auth_spec.rb

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

data/spec/wcc/data/response_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Response do
-  let(:unit) { WCC::Data::Response }
-  let(:raw) { double(:faraday_response) }
-  subject { unit.new(raw) }
-
-  describe "#initialize" do
-    it "takes a Faraday response object and sets it to @raw" do
-      expect(subject.raw).to eq(raw)
-    end
-  end
-
-  describe "method delegation" do
-    it "delegates `body` to @raw" do
-      expect(raw).to receive(:body).and_return(:value)
-      expect(subject.body).to eq(:value)
-      expect(subject.respond_to?(:body)).to be_truthy
-    end
-
-    it "delegates `headers` to @raw" do
-      expect(raw).to receive(:headers).and_return(:value)
-      expect(subject.headers).to eq(:value)
-      expect(subject.respond_to?(:headers)).to be_truthy
-    end
-
-    it "delegates `status` to @raw" do
-      expect(raw).to receive(:status).and_return(:value)
-      expect(subject.status).to eq(:value)
-      expect(subject.respond_to?(:status)).to be_truthy
-    end
-
-    it "delegates `success?` to @raw" do
-      expect(raw).to receive(:success?).and_return(:value)
-      expect(subject.success?).to eq(:value)
-      expect(subject.respond_to?(:success?)).to be_truthy
-    end
-  end
-
-  describe "#json" do
-    it "returns JSON deserialized body" do
-      expect(raw).to receive(:body) {
-        %[{"name":"Bob","interests":["Fishing","Rowing","Golfing"]}]
-      }
-      expect(subject.json).to eq({
-        "name" => "Bob",
-        "interests" => ["Fishing", "Rowing", "Golfing"],
-      })
-    end
-
-    it "returns nil if body is not valid JSON" do
-      expect(raw).to receive(:body) { "" }
-      expect(subject.json).to be_nil
-    end
-  end
-
-end