active_cached_resource 0.0.1.pre

data/lib/activeresource/test/cases/reflection_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+require "fixtures/person"
+require "fixtures/customer"
+
+
+
+class ReflectionTest < ActiveSupport::TestCase
+  def test_correct_class_attributes
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, {})
+    assert_equal :people, object.name
+    assert_equal :test, object.macro
+    assert_equal({}, object.options)
+  end
+
+  def test_correct_class_name_matching_without_class_name
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, {})
+    assert_equal Person, object.klass
+  end
+
+  def test_correct_class_name_matching_as_string
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, class_name: "Person")
+    assert_equal Person, object.klass
+  end
+
+  def test_correct_class_name_matching_as_symbol
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, class_name: :person)
+    assert_equal Person, object.klass
+  end
+
+  def test_correct_class_name_matching_as_class
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, class_name: Person)
+    assert_equal Person, object.klass
+  end
+
+  def test_correct_class_name_matching_as_string_with_namespace
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, class_name: "external/person")
+    assert_equal External::Person, object.klass
+  end
+
+  def test_correct_class_name_matching_as_plural_string_with_namespace
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, class_name: "external/profile_data")
+    assert_equal External::ProfileData, object.klass
+  end
+
+  def test_foreign_key_method_with_no_foreign_key_option
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :person, {})
+    assert_equal "person_id", object.foreign_key
+  end
+
+  def test_foreign_key_method_with_with_foreign_key_option
+    object = ActiveResource::Reflection::AssociationReflection.new(:test, :people, foreign_key: "client_id")
+    assert_equal "client_id", object.foreign_key
+  end
+
+  def test_creation_of_reflection
+    Person.reflections = {}
+    object = Person.create_reflection(:test, :people, {})
+    assert_equal ActiveResource::Reflection::AssociationReflection, object.class
+    assert_equal 1, Person.reflections.count
+    assert_equal Person, Person.reflections[:people].klass
+  end
+end

data/lib/activeresource/test/cases/validations_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "fixtures/project"
+require "active_support/core_ext/hash/conversions"
+
+# The validations are tested thoroughly under ActiveModel::Validations
+# This test case simply makes sure that they are all accessible by
+# Active Resource objects.
+class ValidationsTest < ActiveSupport::TestCase
+  VALID_PROJECT_HASH = { name: "My Project", description: "A project" }
+  def setup
+    @my_proj = { "person" => VALID_PROJECT_HASH }.to_json
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.post "/projects.json", {}, @my_proj, 201, "Location" => "/projects/5.json"
+    end
+  end
+
+  def test_validates_presence_of
+    p = new_project(name: nil)
+    assert_not p.valid?, "should not be a valid record without name"
+    assert_not p.save, "should not have saved an invalid record"
+    assert_equal ["can't be blank"], p.errors[:name], "should have an error on name"
+
+    p.name = "something"
+
+    assert p.save, "should have saved after fixing the validation, but had: #{p.errors.inspect}"
+  end
+
+  def test_fails_save!
+    p = new_project(name: nil)
+    assert_raise(ActiveResource::ResourceInvalid) { p.save! }
+  end
+
+  def test_save_without_validation
+    p = new_project(name: nil)
+    assert_not p.save
+    assert p.save(validate: false)
+  end
+
+  def test_validate_callback
+    # we have a callback ensuring the description is longer than three letters
+    p = new_project(description: "a")
+    assert_not p.valid?, "should not be a valid record when it fails a validation callback"
+    assert_not p.save, "should not have saved an invalid record"
+    assert_equal ["must be greater than three letters long"], p.errors[:description], "should be an error on description"
+
+    # should now allow this description
+    p.description = "abcd"
+    assert p.save, "should have saved after fixing the validation, but had: #{p.errors.inspect}"
+  end
+
+  def test_client_side_validation_maximum
+    project = Project.new(description: "123456789012345")
+    assert_not project.valid?
+    assert_equal ["is too long (maximum is 10 characters)"], project.errors[:description]
+  end
+
+  def test_invalid_method
+    p = new_project
+
+    assert_not p.invalid?
+  end
+
+  def test_validate_bang_method
+    p = new_project(name: nil)
+
+    assert_raise(ActiveModel::ValidationError) { p.validate! }
+  end
+
+  protected
+    # quickie helper to create a new project with all the required
+    # attributes.
+    # Pass in any params you specifically want to override
+    def new_project(opts = {})
+      Project.new(VALID_PROJECT_HASH.merge(opts))
+    end
+end

data/lib/activeresource/test/fixtures/address.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# turns everything into the same object
+class AddressXMLFormatter
+  include ActiveResource::Formats::XmlFormat
+
+  def decode(xml)
+    data = ActiveResource::Formats::XmlFormat.decode(xml)
+    # process address fields
+    data.each do |address|
+      address["city_state"] = "#{address['city']}, #{address['state']}"
+    end
+    data
+  end
+end
+
+class AddressResource < ActiveResource::Base
+  self.element_name = "address"
+  self.format = AddressXMLFormatter.new
+end

data/lib/activeresource/test/fixtures/beast.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class BeastResource < ActiveResource::Base
+  self.site = "http://beast.caboo.se"
+  site.user = "foo"
+  site.password = "bar"
+end
+
+class Forum < BeastResource
+  # taken from BeastResource
+  # self.site = 'http://beast.caboo.se'
+end
+
+class Topic < BeastResource
+  self.site += "/forums/:forum_id"
+end

data/lib/activeresource/test/fixtures/comment.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Comment < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000/posts/:post_id"
+end

data/lib/activeresource/test/fixtures/customer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Customer < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+end

data/lib/activeresource/test/fixtures/inventory.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Inventory < ActiveResource::Base
+  include ActiveResource::Singleton
+  self.site = "http://37s.sunrise.i:3000"
+  self.prefix = "/products/:product_id/"
+
+  schema do
+    integer :total
+    integer :used
+
+    string :status
+  end
+end

data/lib/activeresource/test/fixtures/person.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Person < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+end
+
+module External
+  class Person < ActiveResource::Base
+    self.site = "http://atq.caffeine.intoxication.it"
+  end
+
+  class ProfileData < ActiveResource::Base
+    self.site = "http://external.profile.data.nl"
+  end
+end

data/lib/activeresource/test/fixtures/pet.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Pet < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+  self.prefix = "/people/:person_id/"
+end

data/lib/activeresource/test/fixtures/post.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Post < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+end

data/lib/activeresource/test/fixtures/product.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Product < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+  # X-Inherited-Header is for testing that any subclasses
+  # include the headers of this class
+  self.headers["X-Inherited-Header"] = "present"
+end
+
+class SubProduct < Product
+end

data/lib/activeresource/test/fixtures/project.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# used to test validations
+class Project < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+  schema do
+    string  :email
+    string  :name
+  end
+
+  validates :name, presence: true
+  validates :description, presence: false, length: { maximum: 10 }
+  validate :description_greater_than_three_letters
+
+  # to test the validate *callback* works
+  def description_greater_than_three_letters
+    errors.add :description, "must be greater than three letters long" if description.length < 3 unless description.blank?
+  end
+end

data/lib/activeresource/test/fixtures/proxy.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ProxyResource < ActiveResource::Base
+  self.site = "http://localhost"
+  self.proxy = "http://user:password@proxy.local:3000"
+end

data/lib/activeresource/test/fixtures/sound.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Asset
+  class Sound < ActiveResource::Base
+    self.site = "http://37s.sunrise.i:3000"
+  end
+end
+
+# to test namespacing in a module
+class Author
+end

data/lib/activeresource/test/fixtures/street_address.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class StreetAddress < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000/people/:person_id"
+  self.element_name = "address"
+end

data/lib/activeresource/test/fixtures/subscription_plan.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class SubscriptionPlan < ActiveResource::Base
+  self.site = "http://37s.sunrise.i:3000"
+  self.element_name = "plan"
+  self.primary_key = :code
+end

data/lib/activeresource/test/fixtures/weather.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Weather < ActiveResource::Base
+  include ActiveResource::Singleton
+  self.site = "http://37s.sunrise.i:3000"
+
+  schema do
+    string  :status
+    string  :temperature
+  end
+end
+
+class WeatherDashboard < ActiveResource::Base
+  include ActiveResource::Singleton
+  self.site = "http://37s.sunrise.i:3000"
+  self.singleton_name = "dashboard"
+
+  schema do
+    string :status
+  end
+end

data/lib/activeresource/test/setter_trap.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class SetterTrap < BasicObject
+  class << self
+    def rollback_sets(obj)
+      trapped = new(obj)
+      yield(trapped).tap { trapped.rollback_sets }
+    end
+  end
+
+  def initialize(obj)
+    @cache = {}
+    @obj = obj
+  end
+
+  def respond_to?(method)
+    @obj.respond_to?(method)
+  end
+
+  def method_missing(method, *args, &proc)
+    @cache[method] ||= @obj.send($`) if method.to_s =~ /=$/
+    @obj.send method, *args, &proc
+  end
+
+  def rollback_sets
+    @cache.each { |k, v| @obj.send k, v }
+  end
+end

data/lib/activeresource/test/singleton_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "fixtures/weather"
+require "fixtures/inventory"
+
+class SingletonTest < ActiveSupport::TestCase
+  def setup_weather
+    weather = { status: "Sunny", temperature: 67 }
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get    "/weather.json", {}, weather.to_json
+      mock.get    "/weather.json?degrees=fahrenheit", {}, weather.merge(temperature: 100).to_json
+      mock.post   "/weather.json", {}, weather.to_json, 201, "Location" => "/weather.json"
+      mock.delete "/weather.json", {}, nil
+      mock.put    "/weather.json", {}, nil, 204
+    end
+  end
+
+  def setup_weather_not_found
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get "/weather.json", {}, nil, 404
+    end
+  end
+
+  def setup_inventory
+    inventory = { status: "Sold Out", total: 10, used: 10 }.to_json
+
+    ActiveResource::HttpMock.respond_to do |mock|
+      mock.get "/products/5/inventory.json", {}, inventory
+    end
+  end
+
+  def test_custom_singleton_name
+    assert_equal "dashboard", WeatherDashboard.singleton_name
+  end
+
+  def test_singleton_path
+    assert_equal "/weather.json", Weather.singleton_path
+  end
+
+  def test_singleton_path_with_parameters
+    assert_equal "/weather.json?degrees=fahrenheit", Weather.singleton_path(degrees: "fahrenheit")
+    assert_equal "/weather.json?degrees=false", Weather.singleton_path(degrees: false)
+    assert_equal "/weather.json?degrees=", Weather.singleton_path(degrees: nil)
+
+    assert_equal "/weather.json?degrees=fahrenheit", Weather.singleton_path("degrees" => "fahrenheit")
+
+    # Use include? because ordering of param hash is not guaranteed
+    path = Weather.singleton_path(degrees: "fahrenheit", lunar: true)
+    assert path.include?("weather.json")
+    assert path.include?("degrees=fahrenheit")
+    assert path.include?("lunar=true")
+
+    path = Weather.singleton_path(days: ["monday", "saturday and sunday", nil, false])
+    assert_equal "/weather.json?days%5B%5D=monday&days%5B%5D=saturday+and+sunday&days%5B%5D=&days%5B%5D=false", path
+
+    path = Inventory.singleton_path(product_id: 5)
+    assert_equal "/products/5/inventory.json", path
+
+    path = Inventory.singleton_path({ product_id: 5 }, { sold: true })
+    assert_equal "/products/5/inventory.json?sold=true", path
+  end
+
+  def test_find_singleton
+    setup_weather
+    weather = Weather.send(:find_singleton, Hash.new)
+    assert_not_nil weather
+    assert_equal "Sunny", weather.status
+    assert_equal 67, weather.temperature
+  end
+
+  def test_find
+    setup_weather
+    weather = Weather.find
+    assert_not_nil weather
+    assert_equal "Sunny", weather.status
+    assert_equal 67, weather.temperature
+  end
+
+  def test_find_with_param_options
+    setup_inventory
+    inventory = Inventory.find(params: { product_id: 5 })
+
+    assert_not_nil inventory
+    assert_equal "Sold Out", inventory.status
+    assert_equal 10, inventory.used
+    assert_equal 10, inventory.total
+    assert_equal({ product_id: 5 }, inventory.prefix_options)
+  end
+
+  def test_find_with_query_options
+    setup_weather
+
+    weather = Weather.find(params: { degrees: "fahrenheit" })
+    assert_not_nil weather
+    assert_equal "Sunny", weather.status
+    assert_equal 100, weather.temperature
+  end
+
+  def test_not_found
+    setup_weather_not_found
+
+    assert_raise ActiveResource::ResourceNotFound do
+      Weather.find
+    end
+  end
+
+  def test_create_singleton
+    setup_weather
+    weather = Weather.create(status: "Sunny", temperature: 67)
+    assert_not_nil weather
+    assert_equal "Sunny", weather.status
+    assert_equal 67, weather.temperature
+  end
+
+  def test_destroy
+    setup_weather
+
+    # First Create the Weather
+    weather = Weather.create(status: "Sunny", temperature: 67)
+    assert_not_nil weather
+
+    # Now Destroy it
+    weather.destroy
+  end
+
+  def test_update
+    setup_weather
+
+    # First Create the Weather
+    weather = Weather.create(status: "Sunny", temperature: 67)
+    assert_not_nil weather
+
+    # Then update it
+    weather.status = "Rainy"
+    weather.save
+  end
+end

data/lib/activeresource/test/threadsafe_attributes_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ThreadsafeAttributesTest < ActiveSupport::TestCase
+  class TestClass
+    include ThreadsafeAttributes
+    threadsafe_attribute :safeattr
+  end
+
+  setup do
+    @tester = TestClass.new
+  end
+
+  test "#threadsafe attributes work in a single thread" do
+    assert_not @tester.safeattr_defined?
+    assert_nil @tester.safeattr
+    @tester.safeattr = "a value"
+    assert @tester.safeattr_defined?
+    assert_equal "a value", @tester.safeattr
+  end
+
+  test "#threadsafe attributes inherit the value of the main thread" do
+    @tester.safeattr = "a value"
+    Thread.new do
+      assert @tester.safeattr_defined?
+      assert_equal "a value", @tester.safeattr
+    end.join
+    assert_equal "a value", @tester.safeattr
+  end
+
+  test "#changing a threadsafe attribute in a thread does not affect the main thread" do
+    @tester.safeattr = "a value"
+    Thread.new do
+      @tester.safeattr = "a new value"
+      assert_equal "a new value", @tester.safeattr
+    end.join
+    assert_equal "a value", @tester.safeattr
+  end
+
+  test "#threadsafe attributes inherit the value of the main thread when value is nil/false" do
+    @tester.safeattr = false
+    Thread.new do
+      assert @tester.safeattr_defined?
+      assert_equal false, @tester.safeattr
+    end.join
+    assert_equal false, @tester.safeattr
+  end
+
+  test "#changing a threadsafe attribute in a thread sets an equal value for the main thread, if no value has been set" do
+    assert_not @tester.safeattr_defined?
+    assert_nil @tester.safeattr
+    Thread.new do
+      @tester.safeattr = "value from child"
+      assert_equal "value from child", @tester.safeattr
+    end.join
+    assert @tester.safeattr_defined?
+    assert_equal "value from child", @tester.safeattr
+  end
+
+  test "#threadsafe attributes can retrieve non-duplicable from main thread" do
+    @tester.safeattr = :symbol_1
+    Thread.new do
+      assert_equal :symbol_1, @tester.safeattr
+    end.join
+  end
+
+  test "#threadsafe attributes work in fibers" do
+    @tester.safeattr = :symbol_1
+    Fiber.new do
+      assert_equal :symbol_1, @tester.safeattr
+    end.resume
+  end
+
+  unless RUBY_PLATFORM == "java"
+    test "threadsafe attributes can be accessed after forking within a thread" do
+      reader, writer = IO.pipe
+      @tester.safeattr = "a value"
+      Thread.new do
+        fork do
+          reader.close
+          writer.print(@tester.safeattr)
+          writer.close
+        end
+      end.join
+      writer.close
+      assert_equal "a value", reader.read
+      reader.close
+    end
+  end
+end

data/lib/generators/active_cached_resource/install_generator.rb

@@ -0,0 +1,31 @@
+require "rails/generators/active_record"
+
+module ActiveCachedResource
+  module Generators
+    class ActiveRecordGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+      desc "Generates migration for cache tables"
+
+      source_paths << File.join(File.dirname(__FILE__), "templates")
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def self.migration_version
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+
+      def create_migration_file
+        options = {
+          migration_version: migration_version
+        }
+        migration_template "migration.erb", "db/migrate/create_active_cached_resource_table.rb", options
+      end
+
+      def migration_version
+        self.class.migration_version
+      end
+    end
+  end
+end

data/lib/generators/active_cached_resource/templates/migration.erb

@@ -0,0 +1,16 @@
+class CreateActiveCachedResourceTable < ActiveRecord::Migration<%= migration_version %>
+  def up
+    create_table :active_cached_resources, id: false do |t|
+      t.binary :key, limit: 512, null: false
+      t.binary :value, null: false
+      t.datetime :expires_at, null: false
+
+      t.index [:key, :expires_at], unique: true, name: "index_active_cached_resources_on_key_and_expires_at"
+      t.index :key, name: "index_active_cached_resources_on_key"
+    end
+  end
+
+  def down
+    drop_table :active_cached_resources
+  end
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true