pdc 0.1.0

data/spec/pdc/resource/attributes_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe PDC::Resource::AttributeStore  do
+  subject { PDC::Resource::AttributeStore }
+
+  it '#to_params' do
+    attr = PDC::Resource::AttributeStore.new(
+      id: 3, 'title' => 'Fish',
+      groups: [
+        { name: 'Dessert' }
+      ]
+    )
+    attr.to_params.must_equal(
+      'id'     => 3,
+      'title'  => 'Fish',
+      'groups' => [{ 'name' => 'Dessert' }]
+    )
+  end
+end
+
+describe PDC::Resource::Attributes do
+  it 'returns all attributes' do
+    Product.attributes.wont_be_empty
+  end
+
+  it 'primary_key will be in attributes by default' do
+    Product.attributes.must_include Product.primary_key
+  end
+
+  it 'allows block initialization' do
+    prod = Product.new do |p|
+      p.name = 'RHEL'
+      p.description = 'Enterprise Linux'
+    end
+    assert_equal 'RHEL', prod.name
+    assert_equal 'Enterprise Linux', prod.description
+  end
+
+  it 'can handle predicate' do
+    stub_get('products/1').to_return_json(data: [{ id: 1, name: 'RHEL' }])
+    product = Product.find(1)
+    assert_equal true, product.name?
+    assert_equal false, product.description?
+  end
+
+  it 'can assign a hash' do
+    product = Product.new(id: 2)
+    product.attributes = { name: 'RHEL' }
+
+    product.name.must_equal 'RHEL'
+    product.id.must_equal 2
+  end
+
+  it 'can get and set value' do
+    product = Product.new
+    product.name = 'RHEL'
+    product.name.must_equal 'RHEL'
+  end
+
+  it 'works with []' do
+    product = Product.new(name: 'Fedora')
+    product[:name].must_equal 'Fedora'
+  end
+
+  it 'works with []=' do
+    product = Product.new
+    product[:name] = 'bar'
+    product.name.must_equal 'bar'
+  end
+
+  it 'allows assigning unknown attributes' do
+    product = Product.new
+
+    product.wont_respond_to :foobar
+    product.must_respond_to :foobar=
+
+    product.foobar = 'bar'
+    product.foobar.must_equal 'bar'
+  end
+
+  describe '#respond_to' do
+    it 'returns true for known attributes' do
+      stub_get('products/1').to_return_json(data: [{ id: 1, name: 'RHEL' }])
+
+      product = Product.find(1)
+      product.must_respond_to :name
+    end
+
+    it 'returns false for unknown attributes that are not set' do
+      stub_get('products/1').to_return_json(data: [{ id: 1, name: 'RHEL' }])
+
+      product = Product.find(1)
+      product.wont_respond_to :title
+    end
+
+    it 'returns true for unknown attributes after it is set' do
+      product = Product.new
+      product.wont_respond_to :foobar
+
+      product.foobar = 'bar'
+      product.must_respond_to :foobar
+      Product.attributes.wont_include :foobar
+    end
+  end
+end
+
+describe 'nested hash attributes' do
+  it 'returns OpenStruct for nested hash' do
+    allowed_tags = %w(foo bar baz)
+    stub_get('nested-models/1').to_return_json(
+      data: [{
+        id: 1, name: 'RHEL',
+        nested: {
+          tag: 'foobar',
+          allowed_tags: allowed_tags.clone
+        }
+      }]
+    )
+
+    model = NestedModel.find(1)
+    model.must_respond_to :nested
+    model.nested.must_be_instance_of OpenStruct
+    model.nested.must_respond_to :tag
+    model.nested.must_respond_to :allowed_tags
+    model.nested.tag.must_equal 'foobar'
+    model.nested.allowed_tags.must_equal allowed_tags
+  end
+
+  it 'returns OpenStruct for deep nested hash' do
+    stub_get('nested-models/1').to_return_json(
+      data: [{
+        id: 1, name: 'RHEL',
+        nested: {
+          second_level: {
+            value: 'deep'
+          }
+        }
+      }]
+    )
+
+    model = NestedModel.find(1)
+    model.must_respond_to :nested
+
+    model.nested.must_respond_to :second_level
+    model.nested.second_level.must_be_instance_of OpenStruct
+    model.nested.second_level.must_respond_to :value
+    model.nested.second_level.value.must_equal 'deep'
+  end
+
+  it 'returns OpenStruct for even unregistered attributes' do
+    stub_get('nested-models/1').to_return_json(
+      data: [{
+        id: 1, name: 'RHEL',
+        unregistered_nested: {
+          value: 'unregistered'
+        }
+      }]
+    )
+
+    model = NestedModel.find(1)
+    model.must_respond_to :unregistered_nested
+    model.unregistered_nested.must_be_instance_of OpenStruct
+    model.unregistered_nested.must_respond_to :value
+    model.unregistered_nested.value.must_equal 'unregistered'
+  end
+end
+
+
+describe 'Custom ValueParser' do
+  subject { CustomParserModel }
+  it 'must return fixnum for age' do
+    stub_get('custom-parser-models/1').to_return_json(
+      data: [{
+        id: 1, name: 'RHEL', age: '20'
+      }]
+    )
+
+    model = subject.find(1)
+    model.must_respond_to :age
+    model.age.must_be_instance_of Fixnum
+    model.age.must_equal 20
+  end
+end
+
+# class AttributesTest < MiniTest::Test
+
+  # def test_equality
+    # assert_equal Product.new(id: 2, title: 'Fish'), Product.new(id: 2, title: 'Fish')
+    # refute_equal Product.new(id: 2, title: 'Fish'), Product.new(id: 1, title: 'Fish')
+    # refute_equal Product.new(id: 2, title: 'Fish'), 'not_a_spyke_object'
+    # refute_equal Product.new(id: 2, title: 'Fish'), Image.new(id: 2, title: 'Fish')
+    # refute_equal Product.new, Product.new
+    # refute_equal StepImage.new(id: 1), Image.new(id: 1)
+  # end
+
+  # def test_uniqueness
+    # product_1 = Product.new(id: 1)
+    # product_2 = Product.new(id: 1)
+    # product_3 = Product.new(id: 2)
+    # image_1 = Image.new(id: 2)
+    # records = [product_1, product_2, product_3, image_1]
+    # assert_equal [product_1, product_3, image_1], records.uniq
+  # end
+
+  # def test_super_with_explicit_attributes
+    # assert_equal nil, Product.new.description
+  # end
+
+  # def test_inheriting_explicit_attributes
+    # assert_equal nil, Image.new.description
+    # assert_equal nil, Image.new.caption
+    # assert_raises NoMethodError do
+      # Image.new.note
+    # end
+    # assert_equal nil, StepImage.new.description
+    # assert_equal nil, StepImage.new.caption
+    # assert_equal nil, StepImage.new.note
+  # end
+
+  # def test_inspect
+    # product = Product.new(id: 2, title: 'Pizza', description: 'Delicious')
+    # assert_equal '#<Product(products/(:id)) id: 2 title: "Pizza" description: "Delicious">', product.inspect
+    # product = Product.new
+    # assert_equal '#<Product(products/(:id)) id: nil >', product.inspect
+    # require 'pry'; binding.pry
+    # user = Product.new.build_user
+    # assert_equal '#<User(users/:uuid) id: nil >', user.inspect
+    # group = Product.new.groups.build
+    # assert_equal '#<Group(products/:product_id/groups/(:id)) id: nil product_id: nil>', group.inspect
+  # end
+# end

data/spec/pdc/resource/cache_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'timecop' # for  Timecop.freeze
+
+# How it works
+#
+# The test records http response using +vcr+ as fixtures which are
+# stored under spec/fixtures/vcr directory. After the response is
+# stored as fixtures, vcr will start replaying those requests when
+# same url is accessed by faraday.
+#
+# To deal with the cache expiry, the cache_store is set to in-memory so
+# that the first fetch will be missed and handled by vcr. Time is
+# frozen to 2016 which makes the cache valid/fresh after it is
+# fetched/played once by vcr.
+
+# NOTE: disable webmock to record a new test
+# WebMock.disable!
+
+# returns http cache status for all http calls made
+# using faraday in the +&block+ passed
+def record_cache_access(&block)
+  cache_access = []
+  record_status = lambda do |*args|
+    event = ActiveSupport::Notifications::Event.new(*args)
+    cache_access << event.payload[:cache_status]
+  end
+  ActiveSupport::Notifications.subscribed(record_status, 'http_cache.faraday', &block)
+  cache_access
+end
+
+
+describe 'Caching' do
+  before do
+    @old_config = PDC.config
+    config = @old_config.clone
+    config.disable_caching = false
+    config.cache_store = ActiveSupport::Cache.lookup_store(:memory_store)
+
+    PDC.config = config
+
+    VCR.insert_cassette fixture_name
+    Timecop.travel(Time.local(2016)) #   based on fixtures
+  end
+
+  after do
+    Timecop.return
+    VCR.eject_cassette
+    PDC.config = @old_config
+  end
+
+  it 'caches response without query' do
+    cache = record_cache_access { PDC::V1::Release.scoped.contents! }
+    cache.must_equal [:miss]
+
+    cache = record_cache_access { PDC::V1::Release.scoped.contents! }
+    cache.must_equal [:fresh]
+
+    cache = record_cache_access { PDC::V1::Release.scoped.contents! }
+    cache.must_equal [:fresh]
+  end
+
+  it 'caches response with a query' do
+    cache = record_cache_access { PDC::V1::Release.page(2).contents! }
+    cache.must_equal [:miss]
+
+    cache = record_cache_access { PDC::V1::Release.page(2).contents! }
+    cache.must_equal [:fresh]
+  end
+
+  it 'caches response with multiple query' do
+    cache = record_cache_access do
+      PDC::V1::Release.page(2).page_size(30).contents!
+      PDC::V1::Release.page(2).page_size(30).contents!
+    end
+    cache.must_equal [:miss, :fresh]
+  end
+
+  it 'caches multiple response' do
+    cache = record_cache_access { PDC::V1::Release.where(active: true).all }
+
+    # must paginate so at least 2 pages
+    cache.length.must_be :>=, 2
+    cache.must_equal [:miss] * cache.length
+
+    second_time = record_cache_access { PDC::V1::Release.where(active: true).all }
+    second_time.must_equal [:fresh] * cache.length
+  end
+end

data/spec/pdc/resource/count_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+#WebMock.disable!  # enable to re-record
+
+describe PDC do
+  before do
+    VCR.insert_cassette fixture_name
+  end
+
+  after do
+    VCR.eject_cassette
+  end
+
+  describe 'count' do
+    let(:release) { PDC::V1::Release }
+    let(:arch) { PDC::V1::Arch }
+
+    it 'must return number of resources' do
+      count = release.count
+      count.must_equal 54
+    end
+
+    it 'works with where' do
+      count = release.where(active: false).count
+      count.must_equal 0
+    end
+
+    it 'returns the total count and not items in page' do
+      total_count = arch.count
+      page_count = arch.page(2).count
+      page_count.must_equal total_count
+
+      arch_in_page = arch.page(2).contents!
+      arch_in_page.length.must_be :<, page_count
+    end
+
+    it '.page.count returns total count' do
+      pg2 = arch.page(2)
+      pg2_count = pg2.all.length
+
+      arches_count = pg2.count      # must return all arches count
+      arches_count.wont_equal pg2_count
+    end
+  end
+end

data/spec/pdc/resource/identity_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'ap'
+
+describe ModelWithIdentity do
+  subject { ModelWithIdentity }
+
+  describe '##primary_key' do
+    it 'must exist' do
+      class_methods = subject.methods - subject.instance_methods
+      class_methods.must_include :primary_key
+    end
+
+    it 'must default to class_name_id' do
+      subject.primary_key.must_equal 'model_with_identity_id'
+    end
+  end
+
+  describe 'uri' do
+    it 'must have a default uri' do
+      subject.uri.wont_be_nil
+      subject.uri.must_equal 'fixtures/model-with-identities/(:model_with_identity_id)'
+    end
+
+    it 'returns path with variables expanded for an object' do
+      instance = subject.new(subject.primary_key => :foobar)
+      expected_uri = PDC::Resource::Path.new('fixtures/model-with-identities/foobar').expanded
+      instance.uri.must_equal expected_uri
+    end
+  end
+
+  describe 'new' do
+    it 'returns nil for id' do
+      object = subject.new
+      object.id.must_be_nil
+    end
+
+    it 'can accept primary_key' do
+      pkey = subject.primary_key
+      instance = subject.new(pkey => 'something')
+      instance.id.must_equal 'something'
+      instance.model_with_identity_id.must_equal 'something'
+    end
+  end
+end
+
+describe CustomPrimaryKeyModel do
+  subject { CustomPrimaryKeyModel }
+
+  describe '##primary_key' do
+    it 'can be set' do
+      subject.primary_key.must_equal :foobar
+    end
+  end
+
+  it 'can accept primary_key' do
+    pkey = subject.primary_key
+    object = subject.new(pkey => 'something')
+    object.id.must_equal 'something'
+    object.foobar.must_equal 'something'
+  end
+
+  describe 'uri' do
+    it 'must use custom primary_key' do
+      subject.uri.must_equal 'fixtures/custom-primary-key-models/(:foobar)'
+    end
+  end
+end
+
+
+describe V1::Foobar do
+  subject { V1::Foobar }
+  it 'must have a pkey' do
+    subject.primary_key.must_equal 'foobar_id'
+  end
+
+  it 'must have a uri' do
+    subject.uri.must_equal 'fixtures/v1/foobars/(:foobar_id)'
+  end
+end
+
+describe 'attributes' do
+  it 'base must have primary key' do
+    ModelBase.new.id.must_be_nil
+    base = ModelBase.new(model_base_id: 1)
+    base.id.must_equal 1
+    base.attributes.must_include :model_base_id
+  end
+
+  it 'sub must not have primary key of base' do
+    Model.new.id.must_be_nil
+    model = Model.new(model_id: 3)
+    model.id.must_equal 3
+    model.attributes.must_include :model_id
+    model.attributes.wont_include :model_base_id
+  end
+end

data/spec/pdc/resource/pagination_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe PDC do
+  before do
+    VCR.insert_cassette fixture_name
+  end
+
+  after do
+    VCR.eject_cassette
+  end
+
+  describe 'pagination' do
+    let(:arch) { PDC::V1::Arch }
+    let(:release_variant) { PDC::V1::ReleaseVariant }
+
+    it 'can iterate using each' do
+      count = arch.count   # makes single call
+
+      all = arch.scoped.each_with_object([]) do |a, o|
+        o << a
+      end
+      count.must_equal all.length
+    end
+
+    it 'preserves the filters' do
+      variants = release_variant.where(type: 'variant', name: 'rh-common')
+      count = variants.count
+
+      all = variants.each_with_object([]) do |a, o|
+        o << a
+      end
+      count.must_equal all.length
+    end
+  end
+
+  describe 'page' do
+    subject { PDC::V1::Arch }
+    it 'returns resources on that page' do
+      pg2 = subject.page(2)
+      resources =  pg2.contents!
+      resources.length.must_equal 20
+    end
+
+    it 'should not be in the list of attributes' do
+      pg2 = subject.page(2)
+      arch =  pg2.all.first
+      arch.attributes.wont_include :page
+      arch.attributes.wont_include 'page'
+    end
+  end
+end

data/spec/pdc/resource/path_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe PDC::Resource::Path do
+  subject { PDC::Resource::Path }
+
+  it 'can handle optional variables' do
+    assert_equal '/recipes/(:id)', subject.new('/recipes/(:id)').to_s
+    assert_equal '/recipes', subject.new('/recipes/(:id)').expanded
+    assert_equal '/recipes/2', subject.new('/recipes/(:id)', id: 2).expanded
+  end
+
+  it 'nested collections' do
+    path = subject.new('/users/:user_id/recipes/(:id)',
+                       user_id: 1, status: 'published')
+
+    assert_equal [:user_id, :id], path.variables
+    assert_equal '/users/1/recipes', path.expanded
+  end
+
+
+  it 'nested_resource_path' do
+    assert_equal '/users/1/recipes/2', subject.new('/users/:user_id/recipes/:id', user_id: 1, id: 2).expanded
+  end
+
+  it 'raises if required_params are missing' do
+    lambda {
+      subject.new('/users/:user_id/recipes/(:id)', id: 2).expanded
+    }.must_raise PDC::InvalidPathError, 'Missing required params: user_id in /users/:user_id/recipes/(:id)'
+  end
+end

data/spec/pdc/resource/relation_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+class SearchableModel < Base
+  attributes :name, :product
+
+  ### NOTE: where() will have no impact since the data is hardcoded
+  def self.fake_data
+    [
+      { name: 'foobar-1', product: 'prod' },
+      { name: 'foobar-2', product: 'prod' },
+      { name: 'foobar-3', product: 'prod' },
+    ]
+  end
+
+  def self.fetch(params)
+    response = OpenStruct.new(
+      body: { data: fake_data },
+      status: 200,
+      env: OpenStruct.new(url: 'http://foobar')
+    )
+
+    PDC::Http::Result.new(response)
+  end
+end
+
+describe SearchableModel do
+  subject { SearchableModel }
+
+
+  describe '#where' do
+    it 'returns a scope with params' do
+      filters = { name: :foobar, age: 10 }
+      rel = subject.where(filters)
+
+      rel.must_be_instance_of PDC::Resource::Relation
+      rel.params.must_equal(filters)
+    end
+
+    it 'can be called multiple times' do
+      filter_name = { name: :foobar }
+      filter_age  = { age: 10 }
+
+      rel = subject.where(filter_name).where(filter_age)
+                   .where(filter_name)
+      rel.must_be_instance_of PDC::Resource::Relation
+
+      filters = filter_name.merge(filter_age)
+      rel.params.must_equal filters
+    end
+  end
+
+  describe '#find' do
+    let(:one_result) { [{ name: 'foobar2', product: 'prod' }] }
+    let(:no_result)  { [] }
+
+    it 'returns a record' do
+      subject.stub(:fake_data, one_result) do
+        result = subject.find(:foobar)
+        result.must_be_instance_of SearchableModel
+      end
+    end
+
+    it 'raises MultipleResultsError more than a record exists' do
+      -> { subject.find(:foobar) }.must_raise PDC::MultipleResultsError
+    end
+
+    it 'raise ResourceNotFound when no record exists' do
+      subject.stub(:fake_data, no_result) do
+        -> { subject.find(:foobar) }.must_raise PDC::ResourceNotFound
+      end
+    end
+  end
+
+  it 'can call first' do
+    first = subject.first
+    first.must_be_instance_of subject
+    first.name.must_equal subject.fake_data.first[:name]
+  end
+
+  describe 'relation' do
+    it 'can call all on a relation' do
+      relation = subject.where(name: :foobar)
+      relation.must_be_instance_of PDC::Resource::Relation
+      results = relation.all
+      results.length.must_equal subject.fake_data.length
+      results.first.must_be_instance_of subject
+    end
+
+    it 'all works with resource' do
+      results = subject.all
+      results.length.must_equal subject.fake_data.length
+    end
+  end
+end

data/spec/pdc/resource/rest_api_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe :find do
+  it 'finds a specific resource' do
+    stub_get('products/1')
+      .to_return_json(data: [{ product_id: 1, title: 'foobar' }])
+
+    product = Fixtures::Product.find(1)
+    product.id.must_equal 1
+    product.product_id.must_equal 1
+    product.title.must_equal 'foobar'
+  end
+
+  it 'must work when primary_key is user defined' do
+    stub_get('product-variants/v2')
+      .to_return_json(data: [{ v_id: 'v2', title: 'variant' }])
+
+    variant = Fixtures::ProductVariant.find('v2')
+    variant.id.must_equal 'v2'
+    variant.v_id.must_equal 'v2'
+    variant.title.must_equal 'variant'
+  end
+end

data/spec/pdc/resource/value_parser_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe PDC::Resource::ValueParser do
+  subject { PDC::Resource::ValueParser }
+
+  it 'must respond_to? parse' do
+    subject.must_respond_to :parse
+  end
+
+  describe '#parse' do
+    it 'must return value for plain types' do
+      subject.parse(:foobar).must_equal :foobar
+    end
+  end
+end