active_cached_resource 0.0.1.pre

data/lib/activeresource/test/cases/base/load_test.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "fixtures/person"
+require "fixtures/street_address"
+require "active_support/core_ext/hash/conversions"
+
+module Highrise
+  class Note < ActiveResource::Base
+    self.site = "http://37s.sunrise.i:3000"
+  end
+
+  class Comment < ActiveResource::Base
+    self.site = "http://37s.sunrise.i:3000"
+  end
+
+  module Deeply
+    module Nested
+      class Note < ActiveResource::Base
+        self.site = "http://37s.sunrise.i:3000"
+      end
+
+      class Comment < ActiveResource::Base
+        self.site = "http://37s.sunrise.i:3000"
+      end
+
+      module TestDifferentLevels
+        class Note < ActiveResource::Base
+          self.site = "http://37s.sunrise.i:3000"
+        end
+      end
+    end
+  end
+end
+
+
+class BaseLoadTest < ActiveSupport::TestCase
+  class FakeParameters
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def to_hash
+      @attributes
+    end
+  end
+
+  def setup
+    @matz = { id: 1, name: "Matz" }
+
+    @first_address = { address: { id: 1, street: "12345 Street" } }
+    @addresses = [@first_address, { address: { id: 2, street: "67890 Street" } }]
+    @addresses_from_json = { street_addresses: @addresses }
+    @addresses_from_json_single = { street_addresses: [ @first_address ] }
+
+    @deep  = { id: 1, street: {
+      id: 1, state: { id: 1, name: "Oregon",
+        notable_rivers: [
+          { id: 1, name: "Willamette" },
+          { id: 2, name: "Columbia", rafted_by: @matz }],
+        postal_codes: [ 97018, 1234567890 ],
+        dates: [ Time.now ],
+        votes: [ true, false, true ],
+        places: [ "Columbia City", "Unknown" ] } } }
+
+
+    # List of books formatted as [{timestamp_of_publication => name}, ...]
+    @books = { books: [
+        { 1009839600 => "Ruby in a Nutshell" },
+        { 1199142000 => "The Ruby Programming Language" }
+      ] }
+
+    @books_date = { books: [
+        { Time.at(1009839600) => "Ruby in a Nutshell" },
+        { Time.at(1199142000) => "The Ruby Programming Language" }
+    ] }
+
+    @complex_books = {
+      books: {
+        "Complex.String&-Character*|=_+()!~": {
+          isbn: 1009839690,
+          author: "Frank Smith"
+        },
+        "16Candles": {
+          isbn: 1199142400,
+          author: "John Hughes"
+        }
+      }
+    }
+
+    @person = Person.new
+  end
+
+  def test_load_hash_with_integers_as_keys_creates_stringified_attributes
+    Person.__send__(:remove_const, :Book) if Person.const_defined?(:Book)
+    assert_not Person.const_defined?(:Book), "Books shouldn't exist until autocreated"
+    assert_nothing_raised { @person.load(@books) }
+    assert_equal @books[:books].map { |book| book.stringify_keys }, @person.books.map(&:attributes)
+  end
+
+  def test_load_hash_with_dates_as_keys_creates_stringified_attributes
+    Person.__send__(:remove_const, :Book) if Person.const_defined?(:Book)
+    assert_not Person.const_defined?(:Book), "Books shouldn't exist until autocreated"
+    assert_nothing_raised { @person.load(@books_date) }
+    assert_equal @books_date[:books].map { |book| book.stringify_keys }, @person.books.map(&:attributes)
+  end
+
+  def test_load_hash_with_unacceptable_constant_characters_creates_unknown_resource
+    Person.__send__(:remove_const, :Books) if Person.const_defined?(:Books)
+    assert_not Person.const_defined?(:Books), "Books shouldn't exist until autocreated"
+    assert_nothing_raised { @person.load(@complex_books) }
+    assert Person::Books.const_defined?(:UnnamedResource), "UnnamedResource should have been autocreated"
+    @person.books.attributes.keys.each { |key| assert_kind_of Person::Books::UnnamedResource, @person.books.attributes[key] }
+  end
+
+  def test_load_expects_hash
+    assert_raise(ArgumentError) { @person.load nil }
+    assert_raise(ArgumentError) { @person.load '<person id="1"/>' }
+  end
+
+  def test_load_simple_hash
+    assert_equal Hash.new, @person.attributes
+    assert_equal @matz.stringify_keys, @person.load(@matz).attributes
+  end
+
+  def test_load_object_with_implicit_conversion_to_hash
+    assert_equal @matz.stringify_keys, @person.load(FakeParameters.new(@matz)).attributes
+  end
+
+  def test_after_load_attributes_are_accessible
+    assert_equal Hash.new, @person.attributes
+    assert_equal @matz.stringify_keys, @person.load(@matz).attributes
+    assert_equal @matz[:name], @person.attributes["name"]
+  end
+
+  def test_after_load_attributes_are_accessible_via_indifferent_access
+    assert_equal Hash.new, @person.attributes
+    assert_equal @matz.stringify_keys, @person.load(@matz).attributes
+    assert_equal @matz[:name], @person.attributes["name"]
+    assert_equal @matz[:name], @person.attributes[:name]
+  end
+
+  def test_load_one_with_existing_resource
+    address = @person.load(street_address: @first_address.values.first).street_address
+    assert_kind_of StreetAddress, address
+    assert_equal @first_address.values.first.stringify_keys, address.attributes
+  end
+
+  def test_load_one_with_unknown_resource
+    address = silence_warnings { @person.load(@first_address).address }
+    assert_kind_of Person::Address, address
+    assert_equal @first_address.values.first.stringify_keys, address.attributes
+  end
+
+  def test_load_one_with_unknown_resource_from_anonymous_subclass
+    subclass = Class.new(Person).tap { |c| c.element_name = "person" }
+    address = silence_warnings { subclass.new.load(@first_address).address }
+    assert_kind_of subclass::Address, address
+  end
+
+  def test_load_collection_with_existing_resource
+    addresses = @person.load(@addresses_from_json).street_addresses
+    assert_kind_of Array, addresses
+    addresses.each { |address| assert_kind_of StreetAddress, address }
+    assert_equal @addresses.map { |a| a[:address].stringify_keys }, addresses.map(&:attributes)
+  end
+
+  def test_load_collection_with_unknown_resource
+    Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
+    assert_not Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
+    addresses = silence_warnings { @person.load(addresses: @addresses).addresses }
+    assert Person.const_defined?(:Address), "Address should have been autocreated"
+    addresses.each { |address| assert_kind_of Person::Address, address }
+    assert_equal @addresses.map { |a| a[:address].stringify_keys }, addresses.map(&:attributes)
+  end
+
+  def test_load_collection_with_single_existing_resource
+    addresses = @person.load(@addresses_from_json_single).street_addresses
+    assert_kind_of Array, addresses
+    addresses.each { |address| assert_kind_of StreetAddress, address }
+    assert_equal [ @first_address.values.first ].map(&:stringify_keys), addresses.map(&:attributes)
+  end
+
+  def test_load_collection_with_single_unknown_resource
+    Person.__send__(:remove_const, :Address) if Person.const_defined?(:Address)
+    assert_not Person.const_defined?(:Address), "Address shouldn't exist until autocreated"
+    addresses = silence_warnings { @person.load(addresses: [ @first_address ]).addresses }
+    assert Person.const_defined?(:Address), "Address should have been autocreated"
+    addresses.each { |address| assert_kind_of Person::Address, address }
+    assert_equal [ @first_address.values.first ].map(&:stringify_keys), addresses.map(&:attributes)
+  end
+
+  def test_recursively_loaded_collections
+    person = @person.load(@deep)
+    assert_equal @deep[:id], person.id
+
+    street = person.street
+    assert_kind_of Person::Street, street
+    assert_equal @deep[:street][:id], street.id
+
+    state = street.state
+    assert_kind_of Person::Street::State, state
+    assert_equal @deep[:street][:state][:id], state.id
+
+    rivers = state.notable_rivers
+    assert_kind_of Array, rivers
+    assert_kind_of Person::Street::State::NotableRiver, rivers.first
+    assert_equal @deep[:street][:state][:notable_rivers].first[:id], rivers.first.id
+    assert_equal @matz[:id], rivers.last.rafted_by.id
+
+    postal_codes = state.postal_codes
+    assert_kind_of Array, postal_codes
+    assert_equal 2, postal_codes.size
+    assert_kind_of Integer, postal_codes.first
+    assert_equal @deep[:street][:state][:postal_codes].first, postal_codes.first
+    assert_kind_of Numeric, postal_codes.last
+    assert_equal @deep[:street][:state][:postal_codes].last, postal_codes.last
+
+    places = state.places
+    assert_kind_of Array, places
+    assert_kind_of String, places.first
+    assert_equal @deep[:street][:state][:places].first, places.first
+
+    dates = state.dates
+    assert_kind_of Array, dates
+    assert_kind_of Time, dates.first
+    assert_equal @deep[:street][:state][:dates].first, dates.first
+
+    votes = state.votes
+    assert_kind_of Array, votes
+    assert_kind_of TrueClass, votes.first
+    assert_equal @deep[:street][:state][:votes].first, votes.first
+  end
+
+  def test_nested_collections_within_the_same_namespace
+    n = Highrise::Note.new(comments: [{ comment: { name: "1" } }])
+    assert_kind_of Highrise::Comment, n.comments.first
+  end
+
+  def test_nested_collections_within_deeply_nested_namespace
+    n = Highrise::Deeply::Nested::Note.new(comments: [{ name: "1" }])
+    assert_kind_of Highrise::Deeply::Nested::Comment, n.comments.first
+  end
+
+  def test_nested_collections_in_different_levels_of_namespaces
+    n = Highrise::Deeply::Nested::TestDifferentLevels::Note.new(comments: [{ name: "1" }])
+    assert_kind_of Highrise::Deeply::Nested::Comment, n.comments.first
+  end
+end

data/lib/activeresource/test/cases/base/schema_test.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/core_ext/hash/conversions"
+require "fixtures/person"
+require "fixtures/street_address"
+
+########################################################################
+# Testing the schema of your Active Resource models
+########################################################################
+class SchemaTest < ActiveSupport::TestCase
+  def setup
+    setup_response # find me in abstract_unit
+  end
+
+  def teardown
+    Person.schema = nil # hack to stop test bleedthrough...
+  end
+
+
+  #####################################################
+  # Passing in a schema directly and returning it
+  ####
+
+  test "schema on a new model should be empty" do
+    assert Person.schema.blank?, "should have a blank class schema"
+    assert Person.new.schema.blank?, "should have a blank instance schema"
+  end
+
+  test "schema should only accept a hash" do
+    ["blahblah", ["one", "two"],  [:age, :name], Person.new].each do |bad_schema|
+      assert_raises(ArgumentError, "should only accept a hash (or nil), but accepted: #{bad_schema.inspect}") do
+        Person.schema = bad_schema
+      end
+    end
+  end
+
+  test "schema should accept a simple hash" do
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    assert_nothing_raised { Person.schema = new_schema }
+    assert_equal new_schema, Person.schema
+  end
+
+  test "schema should accept a hash with simple values" do
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    assert_nothing_raised { Person.schema = new_schema }
+    assert_equal new_schema, Person.schema
+  end
+
+  test "schema should accept all known attribute types as values" do
+    ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
+      assert_nothing_raised { Person.schema = { "my_key" => the_type } }
+    end
+  end
+
+  test "schema should not accept unknown values" do
+    bad_values = [ :oogle, :blob, "thing"]
+
+    bad_values.each do |bad_value|
+      assert_raises(ArgumentError, "should only accept a known attribute type, but accepted: #{bad_value.inspect}") do
+        Person.schema = { "key" => bad_value }
+      end
+    end
+  end
+
+  test "schema should accept nil and remove the schema" do
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    assert_nothing_raised { Person.schema = new_schema }
+    assert_equal new_schema, Person.schema # sanity check
+
+    assert_nothing_raised { Person.schema = nil }
+    assert_nil Person.schema, "should have nulled out the schema, but still had: #{Person.schema.inspect}"
+  end
+
+  test "schema should be with indifferent access" do
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    new_schema_syms = new_schema.keys
+
+    assert_nothing_raised { Person.schema = new_schema }
+    new_schema_syms.each do |col|
+      assert Person.new.respond_to?(col.to_s), "should respond to the schema's string key, but failed on: #{col}"
+      assert Person.new.respond_to?(col.to_sym), "should respond to the schema's symbol key, but failed on: #{col.to_sym}"
+    end
+  end
+
+  test "schema on a fetched resource should return all the attributes of that model instance" do
+    p = Person.find(1)
+    s = p.schema
+
+    assert s.present?, "should have found a non-empty schema!"
+
+    p.attributes.each do |the_attr, val|
+      assert s.has_key?(the_attr), "should have found attr: #{the_attr} in schema, but only had: #{s.inspect}"
+    end
+  end
+
+  test "with two instances, default schema should match the attributes of the individual instances - even if they differ" do
+    matz = Person.find(1)
+    rick = Person.find(6)
+
+    m_attrs = matz.attributes.keys.sort
+    r_attrs = rick.attributes.keys.sort
+
+    assert_not_equal m_attrs, r_attrs, "should have different attributes on each model"
+
+    assert_not_equal matz.schema, rick.schema, "should have had different schemas too"
+  end
+
+  test "defining a schema should return it when asked" do
+    assert Person.schema.blank?, "should have a blank class schema"
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    assert_nothing_raised {
+      Person.schema = new_schema
+      assert_equal new_schema, Person.schema, "should have saved the schema on the class"
+      assert_equal new_schema, Person.new.schema, "should have made the schema available to every instance"
+    }
+  end
+
+  test "defining a schema, then fetching a model should still match the defined schema" do
+    # sanity checks
+    assert Person.schema.blank?, "should have a blank class schema"
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    matz = Person.find(1)
+    assert_not matz.schema.blank?, "should have some sort of schema on an instance variable"
+    assert_not_equal new_schema, matz.schema, "should not have the class-level schema until it's been added to the class!"
+
+    assert_nothing_raised {
+      Person.schema = new_schema
+      assert_equal new_schema, matz.schema, "class-level schema should override instance-level schema"
+    }
+  end
+
+
+  #####################################################
+  # Using the schema syntax
+  ####
+
+  test "should be able to use schema" do
+    assert_respond_to Person, :schema, "should at least respond to the schema method"
+
+    assert_nothing_raised do
+      Person.schema { }
+    end
+  end
+
+  test "schema definition should store and return attribute set" do
+    assert_nothing_raised do
+      s = nil
+      Person.schema do
+        s = self
+        attribute :foo, :string
+      end
+      assert_respond_to s, :attrs, "should return attributes in theory"
+      assert_equal({ "foo" => "string" }, s.attrs, "should return attributes in practice")
+    end
+  end
+
+  test "should be able to add attributes through schema" do
+    assert_nothing_raised do
+      s = nil
+      Person.schema do
+        s = self
+        attribute("foo", "string")
+      end
+      assert s.attrs.has_key?("foo"), "should have saved the attribute name"
+      assert_equal "string", s.attrs["foo"], "should have saved the attribute type"
+    end
+  end
+
+  test "should convert symbol attributes to strings" do
+    assert_nothing_raised do
+      s = nil
+      Person.schema do
+        s = self
+        attribute(:foo, :integer)
+      end
+
+      assert s.attrs.has_key?("foo"), "should have saved the attribute name as a string"
+      assert_equal "integer", s.attrs["foo"], "should have saved the attribute type as a string"
+    end
+  end
+
+  test "should be able to add all known attribute types" do
+    assert_nothing_raised do
+      ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
+        s = nil
+        Person.schema do
+          s = self
+          attribute("foo", the_type)
+        end
+        assert s.attrs.has_key?("foo"), "should have saved the attribute name"
+        assert_equal the_type.to_s, s.attrs["foo"], "should have saved the attribute type of: #{the_type}"
+      end
+    end
+  end
+
+  test "attributes should not accept unknown values" do
+    bad_values = [ :oogle, :blob, "thing"]
+
+    bad_values.each do |bad_value|
+      assert_raises(ArgumentError, "should only accept a known attribute type, but accepted: #{bad_value.inspect}") do
+        Person.schema do
+          attribute "key", bad_value
+        end
+      end
+      assert_not self.respond_to?(bad_value), "should only respond to a known attribute type, but accepted: #{bad_value.inspect}"
+      assert_raises(NoMethodError, "should only have methods for known attribute types, but accepted: #{bad_value.inspect}") do
+        Person.schema do
+          send bad_value, "key"
+        end
+      end
+    end
+  end
+
+  test "should accept attribute types as the type's name as the method" do
+    ActiveResource::Schema::KNOWN_ATTRIBUTE_TYPES.each do |the_type|
+      s = nil
+      Person.schema do
+        s = self
+        send(the_type, "foo")
+      end
+      assert s.attrs.has_key?("foo"), "should now have saved the attribute name"
+      assert_equal the_type.to_s, s.attrs["foo"], "should have saved the attribute type of: #{the_type}"
+    end
+  end
+
+  test "should accept multiple attribute names for an attribute method" do
+    names = ["foo", "bar", "baz"]
+    s = nil
+    Person.schema do
+      s = self
+      string(*names)
+    end
+    names.each do |the_name|
+      assert s.attrs.has_key?(the_name), "should now have saved the attribute name: #{the_name}"
+      assert_equal "string", s.attrs[the_name], "should have saved the attribute as a string"
+    end
+  end
+
+
+  #####################################################
+  # What a schema does for us
+  ####
+
+  # respond_to_missing?
+
+  test "should respond positively to attributes that are only in the schema" do
+    new_attr_name = :my_new_schema_attribute
+    new_attr_name_two = :another_new_schema_attribute
+    assert Person.schema.blank?, "sanity check - should have a blank class schema"
+
+    assert_not Person.new.respond_to?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
+    assert_not Person.new.respond_to?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
+
+    assert_nothing_raised do
+      Person.schema = { new_attr_name.to_s => "string" }
+      Person.schema { string new_attr_name_two }
+    end
+
+    assert_respond_to Person.new, new_attr_name, "should respond to the attribute in a passed-in schema, but failed on: #{new_attr_name}"
+    assert_respond_to Person.new, new_attr_name_two, "should respond to the attribute from the schema, but failed on: #{new_attr_name_two}"
+  end
+
+  test "should not care about ordering of schema definitions" do
+    new_attr_name = :my_new_schema_attribute
+    new_attr_name_two = :another_new_schema_attribute
+
+    assert Person.schema.blank?, "sanity check - should have a blank class schema"
+
+    assert_not Person.new.respond_to?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
+    assert_not Person.new.respond_to?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
+
+    assert_nothing_raised do
+      Person.schema { string new_attr_name_two }
+      Person.schema = { new_attr_name.to_s => "string" }
+    end
+
+    assert_respond_to Person.new, new_attr_name, "should respond to the attribute in a passed-in schema, but failed on: #{new_attr_name}"
+    assert_respond_to Person.new, new_attr_name_two, "should respond to the attribute from the schema, but failed on: #{new_attr_name_two}"
+  end
+
+  test "should retrieve the `Method` object" do
+    new_attr_name = :my_new_schema_attribute
+    new_attr_name_two = :another_new_schema_attribute
+    assert Person.schema.blank?, "sanity check - should have a blank class schema"
+
+    assert_not Person.new.respond_to?(new_attr_name), "sanity check - should not respond to the brand-new attribute yet"
+    assert_not Person.new.respond_to?(new_attr_name_two), "sanity check - should not respond to the brand-new attribute yet"
+
+    assert_nothing_raised do
+      Person.schema = { new_attr_name.to_s => "string" }
+      Person.schema { string new_attr_name_two }
+    end
+
+    assert_instance_of Method, Person.new.method(new_attr_name)
+    assert_instance_of Method, Person.new.method(new_attr_name_two)
+  end
+
+  # method_missing effects
+
+  test "should not give method_missing for attribute only in schema" do
+    new_attr_name = :another_new_schema_attribute
+    new_attr_name_two = :another_new_schema_attribute
+
+    assert Person.schema.blank?, "sanity check - should have a blank class schema"
+
+    assert_raises(NoMethodError, "should not have found the attribute: #{new_attr_name} as a method") do
+      Person.new.send(new_attr_name)
+    end
+    assert_raises(NoMethodError, "should not have found the attribute: #{new_attr_name_two} as a method") do
+      Person.new.send(new_attr_name_two)
+    end
+
+    Person.schema = { new_attr_name.to_s => :float }
+    Person.schema { string new_attr_name_two }
+
+    assert_nothing_raised do
+      Person.new.send(new_attr_name)
+      Person.new.send(new_attr_name_two)
+    end
+  end
+
+
+  ########
+  # Known attributes
+  #
+  # Attributes can be known to be attributes even if they aren't actually
+  # 'set' on a particular instance.
+  # This will only differ from 'attributes' if a schema has been set.
+
+  test "new model should have no known attributes" do
+    assert Person.known_attributes.blank?, "should have no known attributes"
+    assert Person.new.known_attributes.blank?, "should have no known attributes on a new instance"
+  end
+
+  test "setting schema should set known attributes on class and instance" do
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    assert_nothing_raised { Person.schema = new_schema }
+
+    assert_equal new_schema.keys.sort, Person.known_attributes.sort
+    assert_equal new_schema.keys.sort, Person.new.known_attributes.sort
+  end
+
+  test "known attributes on a fetched resource should return all the attributes of the instance" do
+    p = Person.find(1)
+    attrs = p.known_attributes
+
+    assert attrs.present?, "should have found some attributes!"
+
+    p.attributes.each do |the_attr, val|
+      assert attrs.include?(the_attr), "should have found attr: #{the_attr} in known attributes, but only had: #{attrs.inspect}"
+    end
+  end
+
+  test "with two instances, known attributes should match the attributes of the individual instances - even if they differ" do
+    matz = Person.find(1)
+    rick = Person.find(6)
+
+    m_attrs = matz.attributes.keys.sort
+    r_attrs = rick.attributes.keys.sort
+
+    assert_not_equal m_attrs, r_attrs, "should have different attributes on each model"
+
+    assert_not_equal matz.known_attributes, rick.known_attributes, "should have had different known attributes too"
+  end
+
+  test "setting schema then fetching should add schema attributes to the instance attributes" do
+    # an attribute in common with fetched instance and one that isn't
+    new_schema = { "age" => "integer", "name" => "string",
+      "height" => "float", "bio" => "text",
+      "weight" => "decimal", "photo" => "binary",
+      "alive" => "boolean", "created_at" => "timestamp",
+      "thetime" => "time", "thedate" => "date", "mydatetime" => "datetime" }
+
+    assert_nothing_raised { Person.schema = new_schema }
+
+    matz = Person.find(1)
+    known_attrs = matz.known_attributes
+
+    matz.attributes.keys.each do |the_attr|
+      assert known_attrs.include?(the_attr), "should have found instance attr: #{the_attr} in known attributes, but only had: #{known_attrs.inspect}"
+    end
+    new_schema.keys.each do |the_attr|
+      assert known_attrs.include?(the_attr), "should have found schema attr: #{the_attr} in known attributes, but only had: #{known_attrs.inspect}"
+    end
+  end
+
+  test "known attributes should be unique" do
+    new_schema = { "age" => "integer", "name" => "string" }
+    Person.schema = new_schema
+    assert_equal Person.new(age: 20, name: "Matz").known_attributes, ["age", "name"]
+  end
+end