card 1.91 → 1.92

data/spec/models/card/type_transition_spec.rb

@@ -1,132 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-class Card
-  cattr_accessor :count
-
-  class Set::Type
-    module CardtypeA
-      extend Card::Set
-
-      def ok_to_delete
-        deny_because "not allowed to delete card a"
-      end
-    end
-
-    # module CardtypeC
-    #   extend Card::Set
-    # end
-
-    module CardtypeD
-      def valid?
-        errors.add :create_error, "card d always has errors"
-        errors.empty?
-      end
-    end
-
-    module CardtypeE
-      def self.included _base
-        Card.count = 2
-      end
-
-      def on_type_change
-        decrement_count
-      end
-
-      def decrement_count
-        Card.count -= 1
-      end
-    end
-
-    module CardtypeF
-      def self.included _base
-        Card.count = 2
-      end
-
-      # FIXME: create_extension doesn't exist anymore, need another hook
-      def create_extension
-        increment_count
-      end
-
-      def increment_count
-        Card.count += 1
-      end
-    end
-  end
-end
-
-describe Card, "with role" do
-  before do
-    Card::Auth.as_bot do
-      @role = Card.search(type: "Role")[0]
-    end
-  end
-
-  it "has a role type" do
-    expect(@role.type_id).to eq(Card::RoleID)
-  end
-end
-
-describe Card, "with account" do
-  before do
-    Card::Auth.as_bot do
-      @joe = change_card_to_type("Joe User", :basic)
-    end
-  end
-
-  it "does not have errors" do
-    expect(@joe.errors.empty?).to eq(true)
-  end
-
-  it "allows type changes" do
-    expect(@joe.type_code).to eq(:basic)
-  end
-end
-
-describe Card, "type transition approve create" do
-  it "has cardtype b create role r1" do
-    expect((c = Card.fetch("Cardtype B+*type+*create")).content).to eq("[[r1]]")
-    expect(c.type_code).to eq(:pointer)
-  end
-
-  it "has errors" do
-    c = change_card_to_type "basicname", "cardtype_b"
-    expect(c.errors[:permission_denied]).not_to be_empty
-  end
-
-  it "is the original type" do
-    -> { change_card_to_type "basicname", "cardtype_b" }
-    expect(Card["basicname"].type_code).to eq(:basic)
-  end
-end
-
-describe Card, "type transition delete callback" do
-  before do
-    @c = change_card_to_type("type-e-card", :basic)
-  end
-
-  it "changes type of the card" do
-    expect(Card["type-e-card"].type_code).to eq(:basic)
-  end
-end
-
-describe Card, "type transition create callback" do
-  before do
-    Card::Auth.as_bot do
-      Card.create name: "Basic+*type+*delete", type: "Pointer",
-                  content: "[[Anyone Signed in]]"
-    end
-    @c = change_card_to_type("basicname", :cardtype_f)
-  end
-
-  it "changes type of card" do
-    expect(Card["basicname"].type_code).to eq(:cardtype_f)
-  end
-end
-
-def change_card_to_type name, type
-  card = Card.fetch(name)
-  card.type_id =
-    type.is_a?(Symbol) ? Card::Codename[type] : Card.fetch_id(type)
-  card.save
-  card
-end

data/spec/models/card/validation_spec.rb

@@ -1,34 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card, "validate name" do
-  it "errors on name with /" do
-    @c = Card.create name: "testname/"
-    expect(@c.errors[:name]).not_to be_blank
-  end
-
-  it "errors on junction name  with /" do
-    @c = Card.create name: "jasmin+ri/ce"
-    expect(@c.errors[:name]).not_to be_blank
-  end
-
-  it "does not create any new cards when name invalid" do
-    original_card_count = Card.count
-    @c = Card.create name: "jasmin+ri/ce"
-    expect(Card.count).to eq(original_card_count)
-  end
-
-  it "does not allow empty name" do
-    @c = Card.new name: ""
-    expect(@c.valid?).to eq(false)
-    expect(@c.errors[:name]).not_to be_blank
-  end
-
-  # maybe the @c.key= should just throw an error, but now it doesn't take anyway
-  it "does not allow mismatched name and key" do
-    @c = Card.new name: "Test"
-    @c.key = "foo"
-    # @c.key.should == 'test'
-    expect(@c.valid?).to eq(false)
-    # @c.errors[:key].should_not be_blank
-  end
-end

data/spec/support/matchers.rb

@@ -1,74 +0,0 @@
-RSpec::Matchers.define :be_valid do
-  match do |card|
-    value_match?(true, card.errors.empty?)
-  end
-end
-
-RSpec::Matchers.define :be_invalid do
-  match do |card|
-    # valid? clears errors
-    # For a new card we have to call valid? to create the errors.
-    # For a updated card we have to check errors because with valid? we would
-    # loose the errors.
-    @valid = card.errors.empty? && card.valid?
-    # card.errors returns an array, hence we need an extra include matcher
-    values_match?(false, @valid) &&
-      values_match?(include(@error_msg), card.errors[@error_key])
-  end
-
-  description do
-    "be invalid #{"because of #{@error_key} #{@error_msg}" if @error_key}"
-  end
-
-  chain(:because_of) do |reason|
-    @error_key, @error_msg = reason.to_a.first
-  end
-
-  failure_message do |actual|
-    super() + fail_reason(actual)
-  end
-
-  def fail_reason actual
-    if @valid
-      "but file is valid"
-    else
-      "but it is invalid because of #{actual.errors.messages}"
-    end
-  end
-end
-
-RSpec::Matchers.define :have_file do |trait|
-  match do |card|
-    trait ||= :file
-    (@file = card.fetch(trait: trait)) && file_size_matches
-  end
-
-  description do
-    "have a file attached #{"of size #{@size}" if @size}"
-  end
-
-  chain(:of_size) { |size| @size = size }
-
-  failure_message do |_actual|
-    if @size
-      "#{super()} but file size is #{@file.file.size}"
-    else
-      "#{super()} but found no file"
-    end
-  end
-
-  failure_message_when_negated do |_actual|
-    if @size
-      "#{super()} but file size is #{@file.file.size}"
-    else
-      "#{super()} but found a file"
-    end
-  end
-
-  private
-
-  def file_size_matches
-    return true unless @size
-    @size === @file.file.size
-  end
-end