card 1.93.3 → 1.93.4

data/spec/models/card/trash_spec.rb

@@ -1,189 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require "card/action"
-
-describe Card, "deleting card" do
-  it "requires permission" do
-    a = Card["a"]
-    Card::Auth.as :anonymous do
-      expect(a.ok?(:delete)).to eq(false)
-      expect(a.delete).to eq(false)
-      expect(a.errors[:permission_denied]).not_to be_empty
-      expect(Card["a"].trash).to eq(false)
-    end
-  end
-end
-
-describe Card, "in trash" do
-  it "is retrieved by fetch with new" do
-    Card.create(name: "Betty").delete
-    c = Card.fetch "Betty", new: {}
-    c.save
-    expect(Card["Betty"]).to be_instance_of(Card)
-  end
-end
-
-describe Card, "plus cards" do
-  it "is deleted when root is" do
-    Card::Auth.as "joe_admin" do
-      c = Card.create! name: "zz+top"
-      root = Card["zz"]
-      root.delete
-      #      Rails.logger.info "ERRORS = #{root.errors.full_messages*''}"
-      expect(Card.find(c.id).trash).to be_truthy
-      expect(Card["zz"]).to be_nil
-    end
-  end
-end
-
-# NOT WORKING, BUT IT SHOULD
-# describe Card, "a part of an unremovable card" do
-#  before do
-#     Card::Auth.as(Card::WagnBotID)
-#     # this ugly setup makes it so A+Admin is the actual user with edits..
-#     Card["Wagn Bot"].update_attributes! name: "A+Wagn Bot"
-#  end
-#  it "does not be removable" do
-#    @a = Card['A']
-#    @a.delete.should_not be_true
-#  end
-# end
-
-describe Card, "rename to trashed name" do
-  before do
-    Card::Auth.as_bot do
-      @a = Card["A"]
-      @b = Card["B"]
-      @a.delete!  # trash
-      @b.update_attributes! name: "A", update_referers: true
-    end
-  end
-
-  it "renames b to a" do
-    expect(@b.name).to eq("A")
-  end
-
-  it "renames a to a*trash" do
-    expect((c = Card.find(@a.id)).name.to_s).to eq("A*trash")
-    expect(c.name).to eq("A*trash")
-    expect(c.key).to eq("a*trash")
-  end
-end
-
-describe Card, "sent to trash" do
-  before do
-    Card::Auth.as_bot do
-      @c = Card["basicname"]
-      @c.delete!
-    end
-  end
-
-  it "is trash" do
-    expect(@c.trash).to eq(true)
-  end
-
-  it "does not be findable by name" do
-    expect(Card["basicname"]).to eq(nil)
-  end
-
-  it "still has actions" do
-    expect(@c.actions.count).to eq(2)
-    expect(@c.last_change_on(:db_content).value).to eq("basiccontent")
-  end
-end
-
-describe Card, "revived from trash" do
-  before do
-    Card::Auth.as_bot do
-      Card["basicname"].delete!
-
-      @c = Card.create! name: "basicname", content: "revived content"
-    end
-  end
-
-  it "does not be trash" do
-    expect(@c.trash).to eq(false)
-  end
-
-  it "has 3 actions" do
-    expect(@c.actions.count).to eq(3)
-  end
-
-  it "still has old content" do
-    expect(@c.nth_action(1).value :db_content).to eq("basiccontent")
-  end
-
-  it "has the same content" do
-    expect(@c.content).to eq("revived content")
-    #    Card.fetch(@c.name).content.should == 'revived content'
-  end
-end
-
-describe Card, "recreate trashed card via new" do
-  #  before do
-  #    Card::Auth.as(Card::WagnBotID)
-  #    @c = Card.create! type: 'Basic', name: "BasicMe"
-  #  end
-
-  #  this test is known to be broken; we've worked around it for now
-  #  it "deletes and recreate with a different cardtype" do
-  #    @c.delete!
-  #    @re_c = Card.new type: "Phrase", name: "BasicMe", content: "Banana"
-  #    @re_c.save!
-  #  end
-end
-
-describe Card, "junction revival" do
-  before do
-    Card::Auth.as_bot do
-      @c = Card.create! name: "basicname+woot", content: "basiccontent"
-      @c.delete!
-      @c = Card.create! name: "basicname+woot", content: "revived content"
-    end
-  end
-
-  it "isn't trash" do
-    expect(@c.trash).to eq(false)
-  end
-
-  it "has 3 actions" do
-    expect(@c.actions.count).to eq(3)
-  end
-
-  it "still has old action" do
-    expect(@c.nth_action(1).value :db_content).to eq("basiccontent")
-  end
-
-  it "has old content" do
-    expect(@c.db_content).to eq("revived content")
-  end
-end
-
-describe "remove tests" do
-  # I believe this is here to test a bug where cards with certain kinds of references
-  # would fail to delete.  probably less of an issue now that delete is done through
-  # trash.
-  it "test_remove" do
-    assert Card["A"].delete!, "card should be deleteable"
-    assert_nil Card["A"]
-  end
-
-  example "recreate plus card name variant" do
-    Card.create(name: "rta+rtb").delete
-    Card["rta"].update_attributes name: "rta!"
-    Card.create! name: "rta!+rtb"
-    expect(Card["rta!+rtb"]).to be_a Card
-    expect(Card["rta!+rtb"].trash).to be_falsey
-    expect(Card.find_by_key("rtb*trash")).to be_nil
-  end
-
-  example "multiple trash collision" do
-    Card.create(name: "alpha").delete
-    3.times do
-      b = Card.create(name: "beta")
-      b.name = "alpha"
-      assert b.save!
-      b.delete
-    end
-  end
-end

data/spec/models/card_spec.rb

@@ -1,136 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card do
-  describe "test data" do
-    it "is findable by name" do
-      expect(Card["Wagn Bot"]).to be_a Card
-    end
-  end
-
-  describe "creation" do
-    before(:each) do
-      Card::Auth.as_bot do
-        @b = Card.create! name: "New Card", content: "Great Content"
-        @c = Card.find(@b.id)
-      end
-    end
-
-    it "does not have errors"  do expect(@b.errors.size).to eq(0)        end
-    it "has the right class"   do expect(@c.class).to    eq(Card)        end
-    it "has the right key"     do expect(@c.key).to      eq("new_card")  end
-    it "has the right name"    do expect(@c.name).to     eq("New Card")  end
-    it "has the right content" do expect(@c.content).to  eq("Great Content") end
-
-    it "has the right content" do
-      expect(@c.db_content).to eq("Great Content")
-      expect(@c.content).to eq("Great Content")
-    end
-
-    it "is findable by name" do
-      expect(Card["New Card"].class).to eq(Card)
-    end
-  end
-
-  describe "content change should create new action" do
-    before do
-      Card::Auth.as_bot do
-        @c = Card["basicname"]
-        @c.update_attributes! content: "foo"
-      end
-    end
-
-    it "has 2 actions"  do
-      expect(@c.actions.count).to eq(2)
-    end
-
-    it "has original action" do
-      expect(@c.nth_action(1).value :db_content).to eq("basiccontent")
-    end
-  end
-
-  example "creates a virtual card when missing" do
-    expect(Card.new(name: "A+*last edited")).to be_virtual
-  end
-end
-
-describe "basic card tests" do
-  def assert_simple_card card
-    expect(card.name).to be, "name not null"
-    expect(card.name.empty?).to be_falsey, "name not empty"
-    action = card.last_action
-    expect(action).to be_instance_of Card::Action
-    expect(action.act.actor).to be_instance_of Card
-  end
-
-  def assert_samecard card1, card2
-    assert_equal card1, card2
-  end
-
-  def assert_stable card1
-    card2 = Card[card1.name]
-    assert_simple_card card1
-    assert_simple_card card2
-    assert_samecard card1, card2
-    assert_equal card1.right, card2.right
-  end
-
-  it "creates cards" do
-    alpha = Card.new name: "alpha", content: "alpha"
-    expect(alpha.content).to eq("alpha")
-    alpha.save
-    expect(alpha.name).to eq("alpha")
-    assert_stable alpha
-  end
-
-  it "does not find nonexistent" do
-    expect(Card["no such card+no such tag"]).to be_nil
-    expect(Card["HomeCard+no such tag"]).to be_nil
-  end
-
-  it "update_should_create_subcards" do
-    Card.create! name: "Banana"
-    Card["banana"].update_attributes! subcards: { "+peel" => { content: "yellow" } }
-
-    peel = Card["Banana+peel"]
-    expect(peel.content).       to eq("yellow")
-    expect(Card["joe_user"].id).to eq(peel.creator_id)
-  end
-
-  it "update_should_create_subcards_as_wagn_bot_if_missing_subcard_permissions" do
-    Card.create name: "peel"
-    Card::Auth.current_id = Card::AnonymousID
-    expect(Card["Banana"]).not_to be
-    expect(Card["Basic"].ok?(:create)).to be_falsey, "anon can't creat"
-
-    Card.create! type: "Fruit", name: "Banana", subcards: { "+peel" => { content: "yellow" } }
-    expect(Card["Banana"]).to be
-    peel = Card["Banana+peel"]
-
-    expect(peel.db_content).to eq("yellow")
-    expect(peel.creator_id).to eq(Card::AnonymousID)
-  end
-
-  context "missing main card permissions" do
-    it "update doesn't create subcards" do
-      b = create! "Banana"
-      Card::Auth.as Card::AnonymousID do
-        b.update_attributes subcards: { "+peel" => { content: "yellow" } }
-        expect(b.errors[:permission_denied]).not_to be_empty
-
-        c = Card.update(b.id, subcards: { "+peel" => { content: "yellow" } })
-        expect(c.errors[:permission_denied]).not_to be_empty
-        expect(Card["Banana+peel"]).to be_nil
-      end
-    end
-  end
-
-
-  it "create_without_read_permission" do
-    c = Card.create!(name: "Banana", type: "Fruit", content: "mush")
-    Card::Auth.as Card::AnonymousID do
-      assert_raises Card::Error::PermissionDenied do
-        c.ok! :read
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,45 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require File.expand_path("../support/card_spec_loader.rb", __FILE__)
-CardSpecLoader.init
-
-require "rr"
-
-CardSpecLoader.prefork do
-  CARD_TEST_SEED_PATH = File.expand_path("../../db/seed/test/fixtures", __FILE__)
-
-  CardSpecLoader.rspec_config do |config|
-    # require 'card-rspec-formatter'
-    config.mock_with :rr
-
-    config.mock_with :rspec do |mocks|
-      mocks.syntax = [:should, :expect]
-      mocks.verify_partial_doubles = true
-    end
-    config.expect_with :rspec do |c|
-      c.syntax = [:should, :expect]
-    end
-  end
-
-  Card["*all+*style"].ensure_machine_output
-  Card["*all+*script"].ensure_machine_output
-  (ie9 = Card[:script_html5shiv_printshiv]) && ie9.ensure_machine_output
-end
-
-CardSpecLoader.each_run do
-  # This code will be run each time you run your specs.
-  require "simplecov"
-end
-
-CardSpecLoader.helper
-
-class ActiveSupport::Logger
-  def rspec msg, console_text=nil
-    if Thread.current["logger-output"]
-      Thread.current["logger-output"] << msg
-    else
-      puts console_text || msg
-    end
-  end
-end
-

data/spec/support/card_spec_helper.rb

@@ -1,74 +0,0 @@
-%w[helper matchers].each do |load_dir|
-  load_path = File.expand_path "../#{load_dir}/*.rb", __FILE__
-  Dir[load_path].each { |f| require f }
-end
-
-
-class Card
-  # to be included in  RSpec::Core::ExampleGroup
-  module SpecHelper
-    include RenderHelper
-    include EventHelper
-    include SaveHelper
-
-    # ~~~~~~~~~  HELPER METHODS ~~~~~~~~~~~~~~~#
-    include Rails::Dom::Testing::Assertions::SelectorAssertions
-
-    def login_as user
-      Card::Auth.current_id = (uc = Card[user.to_s]) && uc.id
-      return unless @request
-      @request.session[:user] = Card::Auth.current_id
-      # warn "(ath)login_as #{user.inspect}, #{Card::Auth.current_id}, "\
-      #      "#{@request.session[:user]}"
-    end
-
-    def assert_view_select view_html, *args, &block
-      node = Nokogiri::HTML::Document.parse(view_html).root
-      if block_given?
-        assert_select node, *args, &block
-      else
-        assert_select node, *args
-      end
-    end
-
-    def debug_assert_view_select view_html, *args, &block
-      log_html view_html
-      assert_view_select view_html, *args, &block
-    end
-
-    def log_html html
-      parsed = CodeRay.scan(Nokogiri::XML(html, &:noblanks).to_s, :html)
-      if Rails.logger.respond_to? :rspec
-        Rails.logger.rspec "#{parsed.div}#{CODE_RAY_STYLE}"
-      else
-        puts parsed.text
-      end
-    end
-
-    CODE_RAY_STYLE = <<-HTML
-      <style>
-        .CodeRay {
-          background-color: #FFF;
-          border: 1px solid #CCC;
-          padding: 1em 0px 1em 1em;
-        }
-        .CodeRay .code pre { overflow: auto }
-      </style>
-    HTML
-
-    def users
-      SharedData::USERS.sort
-    end
-
-    def bucket_credentials key
-      @buckets ||= bucket_credentials_from_yml_file || {}
-      @buckets[key]
-    end
-
-    def bucket_credentials_from_yml_file
-      yml_file = ENV["BUCKET_CREDENTIALS_PATH"] ||
-                 File.expand_path("../bucket_credentials.yml", __FILE__)
-      File.exist?(yml_file) && YAML.load_file(yml_file).deep_symbolize_keys
-    end
-  end
-end

data/spec/support/card_spec_loader.rb

@@ -1,112 +0,0 @@
-class CardSpecLoader
-  class << self
-    def init
-      require "spork"
-      ENV["RAILS_ENV"] = "test"
-      require "timecop"
-    end
-
-    def prefork
-      Spork.prefork do
-        unless ENV["RAILS_ROOT"]
-          raise Card::Error, "No RAILS_ROOT given. Can't load environment."
-        end
-        require File.join ENV["RAILS_ROOT"], "config/environment"
-        load_shared_examples
-        require File.expand_path("../simplecov_helper.rb", __FILE__)
-        require File.expand_path("../../../db/seed/test/seed.rb", __FILE__)
-
-        # Requires supporting ruby files with custom matchers and macros, etc,
-        # in spec/support/ and its subdirectories.
-        Dir[File.join(Cardio.gem_root, "spec/support/matchers/*.rb")].each do |f|
-          require f
-        end
-        yield if block_given?
-      end
-    end
-
-    def each_run
-      # This code will be run each time you run your specs.
-      yield if block_given?
-    end
-
-    def rspec_config
-      require "rspec/rails"
-
-      @@joe_user_id = Card["joe_user"].id
-      RSpec.configure do |config|
-        config.include RSpec::Rails::Matchers::RoutingMatchers,
-                       file_path: %r{\bspec/controllers/}
-        config.include RSpecHtmlMatchers
-        # format_index = ARGV.find_index {|arg| arg =~ /--format|-f/ }
-        # formatter = format_index ? ARGV[ format_index + 1 ] : 'documentation'
-        # config.default_formatter=formatter
-
-        config.infer_spec_type_from_file_location!
-        # config.include CustomMatchers
-        # config.include ControllerMacros, type: :controllers
-
-        # == Mock Framework
-        # If you prefer to mock with mocha, flexmock or RR,
-        # uncomment the appropriate symbol:
-        # :mocha, :flexmock, :rr
-
-        config.use_transactional_fixtures = true
-        config.use_instantiated_fixtures  = false
-
-        config.before(:each) do |example|
-          Delayed::Worker.delay_jobs = false
-          unless example.metadata[:as_bot]
-            user_id =
-              case example.metadata[:with_user]
-              when String
-                Card.fetch_id example.metadata[:with_user]
-              when Card
-                Card.id
-              when Integer
-                example.metadata[:with_user]
-              else
-                @@joe_user_id
-              end
-            Card::Auth.current_id = user_id
-          end
-          Card::Cache.restore
-          Card::Env.reset
-        end
-
-        config.around(:example, :as_bot) do |example|
-          Card::Auth.current_id = @@joe_user_id
-          Card::Auth.as_bot do
-            example.run
-          end
-        end
-
-        config.after(:each) do
-          Timecop.return
-        end
-        yield config if block_given?
-
-        # # only needed for < 3.5.0
-        # [:controller, :view, :request].each do |type|
-        #   config.include ::Rails::Controller::Testing::TestProcess, :type => type
-        #   config.include ::Rails::Controller::Testing::TemplateAssertions, :type => type
-        #   config.include ::Rails::Controller::Testing::Integration, :type => type
-        # end
-      end
-    end
-
-    def helper
-      require File.expand_path "../card_spec_helper.rb", __FILE__
-      RSpec::Core::ExampleGroup.send :include, Card::SpecHelper
-      Card.send :include, Card::SpecHelper::CardHelper
-      Card.send :include, Card::SpecHelper::SetHelper
-      Card.send :extend, Card::SpecHelper::CardHelper::ClassMethods
-    end
-
-    def load_shared_examples
-      Card::Mod.dirs.each "spec/shared_examples" do |shared_ex_dir|
-        Dir["#{shared_ex_dir}/**/*.rb"].sort.each { |f| require f }
-      end
-    end
-  end
-end