active_cached_resource 0.1.0 → 0.1.1

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

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

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