wcc-data 0.3.9 → 0.4.0.pre

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

data/spec/wcc/data/response_spec.rb

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

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

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

data/spec/wcc/data_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe WCC::Data do
+
+  describe "::config" do
+    it "returns a cached instance of Config" do
+      config = WCC::Data.config
+      expect(config).to be_a(WCC::Data::Config)
+      expect(WCC::Data.config).to eq(config)
+    end
+  end
+
+  describe "::setup" do
+    it "yields to the provided block with config" do
+      config = WCC::Data.config
+      called = false
+      WCC::Data.setup do |passed_config|
+        called = true
+        expect(passed_config).to eq(config)
+      end
+      expect(called).to be_truthy
+    end
+  end
+
+end

data/wcc-data.gemspec

@@ -13,13 +13,15 @@ Gem::Specification.new do |spec|
   spec.homepage      = ""
   spec.license       = "MIT"
 
-  spec.files         = Dir['lib/**/*'] + %w[LICENSE.txt README.md wcc-data.gemspec]
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '~> 2.2'
 
-  spec.add_dependency "faraday", "~> 0.8"
+  # Required if you use faraday_client_app_token_auth but must be included separately
+  spec.add_development_dependency "faraday", "~> 0.8"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "dotenv", "~> 0.10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wcc-data
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0.pre
 platform: ruby
 authors:
 - Watermark Dev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-03 00:00:00.000000000 Z
+date: 2021-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -17,7 +17,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -97,12 +97,20 @@ dependencies:
 description: Watermark's library for interapp communication via APIs
 email:
 - dev@watermark.org
-executables: []
+executables:
+- rspec
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
+- ".gitignore"
+- ".rspec"
+- Gemfile
 - LICENSE.txt
 - README.md
+- Rakefile
+- bin/rspec
+- circle.yml
 - lib/wcc/data.rb
 - lib/wcc/data/config.rb
 - lib/wcc/data/enumerated_type.rb
@@ -128,6 +136,22 @@ files:
 - lib/wcc/data/rest_endpoint.rb
 - lib/wcc/data/service.rb
 - lib/wcc/data/version.rb
+- spec/spec_helper.rb
+- spec/support/inheritable_class_attribute_examples.rb
+- spec/wcc/data/config_spec.rb
+- spec/wcc/data/enumerated_type_spec.rb
+- spec/wcc/data/faraday_client_app_token_auth_spec.rb
+- spec/wcc/data/mapper/attributes_spec.rb
+- spec/wcc/data/mapper/json_response_spec.rb
+- spec/wcc/data/mapper/rest_configuration_spec.rb
+- spec/wcc/data/mapper/rest_query_spec.rb
+- spec/wcc/data/model_spec.rb
+- spec/wcc/data/nucleus/campus_spec.rb
+- spec/wcc/data/rack_client_app_token_auth_spec.rb
+- spec/wcc/data/response_spec.rb
+- spec/wcc/data/rest_endpoint_spec.rb
+- spec/wcc/data/service_spec.rb
+- spec/wcc/data_spec.rb
 - wcc-data.gemspec
 homepage: ''
 licenses:
@@ -144,13 +168,29 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project:
 rubygems_version: 2.5.2.3
 signing_key:
 specification_version: 4
 summary: Watermark's library for interapp communication via APIs
-test_files: []
+test_files:
+- spec/spec_helper.rb
+- spec/support/inheritable_class_attribute_examples.rb
+- spec/wcc/data/config_spec.rb
+- spec/wcc/data/enumerated_type_spec.rb
+- spec/wcc/data/faraday_client_app_token_auth_spec.rb
+- spec/wcc/data/mapper/attributes_spec.rb
+- spec/wcc/data/mapper/json_response_spec.rb
+- spec/wcc/data/mapper/rest_configuration_spec.rb
+- spec/wcc/data/mapper/rest_query_spec.rb
+- spec/wcc/data/model_spec.rb
+- spec/wcc/data/nucleus/campus_spec.rb
+- spec/wcc/data/rack_client_app_token_auth_spec.rb
+- spec/wcc/data/response_spec.rb
+- spec/wcc/data/rest_endpoint_spec.rb
+- spec/wcc/data/service_spec.rb
+- spec/wcc/data_spec.rb