wcc-data 0.3.3 → 0.3.7

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,34 +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')
-      expect(campus.code).to eq('FRS')
-    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

data/spec/wcc/data/rest_endpoint_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::RESTEndpoint do
-  let(:service) { WCC::Data::Service.new }
-  subject { described_class.new(service: service) }
-
-  describe "#initialize" do
-    subject { described_class }
-    it "sets @service from :service option" do
-      obj = subject.new(service: service)
-      expect(obj.service).to eq(service)
-    end
-  end
-
-  shared_examples_for :rest_method_general_options do |method, verb, args|
-    let(:test_args) {
-      { foo: "bar", baz: "bing" }
-    }
-    it "takes a hash as last argument and passes to underlying service" do
-      args = Array(args)
-      expect(service).to receive(verb).with(hash_including(test_args))
-      subject.public_send(method, *args, test_args)
-    end
-  end
-
-  describe "#index" do
-    it_behaves_like :rest_method_general_options, :index, :get
-
-    it "calls #get directly on service" do
-      expect(service).to receive(:get).and_return("hi there")
-      expect(subject.index).to eq("hi there")
-    end
-  end
-
-  describe "#show" do
-    it_behaves_like :rest_method_general_options, :show, :get, 1
-
-    it "calls #get on service adding the id param to the URI" do
-      expect(service).to receive(:get).with(uri: "123").and_return("yo")
-      expect(subject.show(123)).to eq("yo")
-    end
-  end
-
-  describe "#create" do
-    it_behaves_like :rest_method_general_options, :create, :post, { test: 1 }
-
-    it "calls #post on service with attrs hash as body" do
-      expect(service).to receive(:post).with(body: { foo: "bar" }).and_return("hey bra")
-      expect(subject.create(foo: "bar")).to eq("hey bra")
-    end
-  end
-
-  describe "#update" do
-    it_behaves_like :rest_method_general_options, :update, :patch, [1, { test: 1 }]
-
-    it "calls #patch on service with id as URI and attrs as body" do
-      expect(service).to receive(:patch).with(uri: "123", body: {}).and_return("sup")
-      expect(subject.update(123, {})).to eq("sup")
-    end
-  end
-
-  describe "#destroy" do
-    it_behaves_like :rest_method_general_options, :destroy, :delete, 1
-
-    it "calls #delete on service with id as URI" do
-      expect(service).to receive(:delete).with(uri: "123").and_return("oh noes!")
-      expect(subject.destroy(123)).to eq("oh noes!")
-    end
-  end
-
-end

data/spec/wcc/data/service_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-describe WCC::Data::Service do
-  let(:unit) { WCC::Data::Service }
-  let(:connection) { double() }
-  let(:default_args) {
-    {
-      uri: "http://test.com/foo/",
-      connection: connection,
-    }
-  }
-  subject { unit.new(default_args) }
-
-  describe "#initialize" do
-    it "sets :uri to @uri" do
-      expect(subject.uri).to eq(URI(default_args[:uri]))
-    end
-
-    it "sets :connection to @connection" do
-      expect(subject.connection).to eq(default_args[:connection])
-    end
-  end
-
-  describe "#merge" do
-    it "returns a new instance" do
-      merged = subject.merge
-      expect(merged).to be_a(unit)
-      expect(merged.object_id).to_not eq(subject.object_id)
-    end
-
-    it "merges the URI params" do
-      merged = subject.merge(uri: "bar/baz?query")
-      expect(merged.uri.path).to eq("/foo/bar/baz")
-      expect(merged.uri.query).to eq("query")
-    end
-
-    it "sets to the right instance's @connection" do
-      connection = :bar
-      merged = subject.merge(connection: connection)
-      expect(merged.connection).to eq(connection)
-    end
-
-    it "accepts a hash of arguments as well as an instance" do
-      right = unit.new(uri: "bar", connection: double())
-      merged = subject.merge(right)
-      expect(merged.uri).to eq(URI("http://test.com/foo/bar"))
-      expect(merged.connection).to eq(right.connection)
-    end
-
-  end
-
-  shared_examples_for :http_verb_methods do
-    it "request verb matches the method name" do
-      expect(connection).to receive(:run_request) do |verb, _, _, _|
-        expect(verb).to eq(method)
-      end
-      subject.send(method, {})
-    end
-
-    it "returns a WCC::Data::Response instance" do
-      expect(connection).to receive(:run_request) {}
-      expect(subject.send(method, {})).to be_a(WCC::Data::Response)
-    end
-
-    it "merges :uri arg onto @uri" do
-      expect(connection).to receive(:run_request) do |_, url, _, _|
-        expect(url).to eq(URI("http://test.com/foo/bar"))
-      end
-      subject.send(method, uri: "bar")
-    end
-
-    it "sets the request body with :body arg" do
-      expect(connection).to receive(:run_request) do |_, _, body, _|
-        expect(body).to eq("a string")
-      end
-      subject.send(method, body: "a string")
-    end
-
-    it "provides request headers with :headers arg" do
-      expect(connection).to receive(:run_request) do |_, _, _, headers|
-        expect(headers).to eq(:foo)
-      end
-      subject.send(method, headers: :foo)
-    end
-
-    it "updates the params on the request if :params argument provided" do
-      params = { foo: "bar" }
-      request = double(params: double(:params))
-      expect(connection).to receive(:run_request).and_yield(request)
-
-      expect(request.params).to receive(:update).with(params)
-      subject.send(method, params: params)
-    end
-
-    it "does not update the params on the request if :params is nil" do
-      request = double(params: double(:params))
-      expect(connection).to receive(:run_request).and_yield(request)
-      expect(request.params).to_not receive(:update)
-      subject.send(method, {})
-    end
-  end
-
-  describe "#get" do
-    let(:method) { :get }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#post" do
-    let(:method) { :post }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#put" do
-    let(:method) { :put }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#patch" do
-    let(:method) { :patch }
-    it_behaves_like :http_verb_methods
-  end
-
-  describe "#delete" do
-    let(:method) { :delete }
-    it_behaves_like :http_verb_methods
-  end
-
-end