ramaze.ch.oddb.org 1.0.0

data/test/suite.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# suite.rb -- oddb -- 08.09.2006 -- hwyss@ywesee.com 
+
+require 'find'
+
+here = File.dirname(__FILE__)
+
+$: << here
+require 'selenium/unit'
+
+Find.find(here) { |file|
+	if /test_.*\.rb$/o.match(file)
+    require file
+	end
+}

data/test/test_model.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# TestModel -- de.oddb.org -- 12.09.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/model'
+
+module ODDB
+  class TestModel < Test::Unit::TestCase
+    include FlexMock::TestCase
+    class Foo < Model
+      multilingual :name
+      has_many :difficulties, on_delete(:cascade)
+    end
+    class Bar < Model
+      has_many :not_in_foos
+    end
+    class Baz < Model
+      belongs_to :foo, on_save(:cascade)
+    end
+    class SelfName < Model
+    end
+    def setup
+      @foo = Foo.new
+    end
+    def test_multilingual
+      assert_respond_to(@foo, :name)
+      assert_instance_of(Util::Multilingual, @foo.name)
+    end
+    def test_has_many
+      assert_equal([:@difficulties], Foo.connectors)
+      assert_respond_to(@foo, :difficulties)
+      assert_equal([], @foo.difficulties)
+      assert_respond_to(@foo, :add_difficulty)
+      @foo.add_difficulty('a difficult String')
+      assert_equal(['a difficult String'], @foo.difficulties)
+      assert_respond_to(@foo, :remove_difficulty)
+      @foo.remove_difficulty('a difficult String')
+      assert_equal([], @foo.difficulties)
+    end
+    def test_belongs_to
+      baz = Baz.new
+      assert_respond_to(baz, :foo)
+      assert_respond_to(baz, :foo=)
+      assert_nil(baz.foo)
+      foo = flexmock('foo')
+      foo.should_receive(:add_baz).times(1).with(baz)
+      foo.should_receive(:save).times(2)
+      baz.foo = foo
+      assert_equal(foo, baz.foo)
+      baz.foo = foo
+      assert_equal(foo, baz.foo)
+      other = flexmock('other')
+      foo.should_receive(:remove_baz).times(1).with(baz)
+      other.should_receive(:add_baz).times(1).with(baz)
+      other.should_receive(:save).times(2)
+      baz.foo = other
+      assert_equal(other, baz.foo)
+      other.should_receive(:remove_baz).times(1).with(baz)
+      baz.foo = nil
+      assert_nil(baz.foo)
+    end
+    def test_singular
+      assert_equal('self_name', SelfName.singular)
+    end
+    def test_predicates__on_delete__cascade
+      diff = flexmock('Difficulty')
+      @foo.add_difficulty(diff)
+      diff.should_receive(:delete).times(1).and_return { assert(true) }
+      @foo.delete
+    end
+    def test_predicates__on_save__cascade
+      baz = Baz.new
+      foo = flexmock('foo')
+      foo.should_receive(:add_baz)
+      foo.should_receive(:save).times(2).and_return { assert(true) }
+      baz.foo = foo
+      baz.save
+    end
+  end
+end

data/test/util/test_code.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# Util::TestCode -- de.oddb.org -- 12.09.2006 -- hwyss@ywesee.com
+
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/util/code'
+
+module ODDB
+  module Util
+    class TestCode < Test::Unit::TestCase
+      def test_registration_ch
+        code = Code.new(:registration, 245, 'ch')
+        assert_equal("CH", code.country)
+        assert_equal("%05i", code.format)
+        assert_equal("00245", code.to_s)
+      end
+      def test_equal
+        code1 = Code.new(:registration, 245, 'ch')
+        code2 = Code.new(:registration, 245, 'ch')
+        code3 = Code.new(:registration, 245, 'de')
+        code4 = Code.new(:registration, 246, 'ch')
+        code5 = Code.new(:substance, 245, 'ch')
+        assert_equal(true, code1 == code2)
+        assert_equal(true, code2 == code1)
+        assert_equal(false, code1 == code3)
+        assert_equal(false, code3 == code1)
+        assert_equal(false, code1 == code4)
+        assert_equal(false, code4 == code1)
+        assert_equal(false, code1 == code5)
+        assert_equal(false, code5 == code1)
+        assert_equal(true, [code1].include?(code2))
+        assert_equal(false, [code1].include?(code3))
+        assert_equal(false, [code1].include?(code4))
+        assert_equal(false, [code1].include?(code5))
+        assert_equal(true, code5 == 245)
+      end
+      def test_format
+        code1 = Code.new(:registration, 245, 'ch')
+        code1.format = "code:%05i"
+        assert_equal("code:00245", code1.to_s)
+      end
+      def test_hash_key
+        code1 = Code.new(:registration, 245, 'ch')
+        code2 = Code.new(:registration, 245, 'ch')
+        code3 = Code.new(:registration, 245, 'de')
+        assert_equal("found", {code1 => "found"}[code2])
+        assert_nil({code1 => "found"}[code3])
+      end
+      def test_dated_values
+        code = Code.new(:registration, 245, 'ch')
+        assert_equal("00245", code.to_s)
+        code.value = 244, Date.today - 10
+        assert_equal(245, code.value)
+        assert_equal(244, code.value(Date.today - 1))
+        code.value = 246, Date.today + 10
+        assert_equal(245, code.value)
+        assert_equal(244, code.value(Date.today - 1))
+        assert_equal(245, code.value(Date.today + 1))
+        assert_equal(246, code.value(Date.today + 10))
+      end
+      def test_include
+        code1 = Code.new(:registration, 245, 'ch')
+        code2 = Code.new(:registration, 245, 'de')
+        code = Code.new(:registration, 245, 'ch')
+        assert_equal(true, [code1].include?(code))
+        assert_equal(false, [code2].include?(code))
+        assert_equal(true, {code1 => true}.include?(code))
+        assert_equal(false, {code2 => true}.include?(code))
+      end
+    end
+  end
+end

data/test/util/test_ipn.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+# Util::TestIpn -- de.oddb.org -- 01.02.2008 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+$: << File.expand_path('..', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'oddb/util/ipn'
+require 'stub/model'
+require 'test/unit'
+
+module ODDB
+  module Util
+class TestIpn < Test::Unit::TestCase
+  include FlexMock::TestCase
+  def setup
+    Drugs::Package.instances.clear
+    Drugs::Product.instances.clear
+    Business::Company.instances.clear
+    super
+  end
+  def test_process__incomplete
+    email = 'test@invoice.ch'
+    invoice = Business::Invoice.new
+    invoice.yus_name = email
+    item = invoice.add :poweruser, "unlimited access", 365, "Tage", 2
+    invoice.save
+
+    note = flexmock('notification')
+    note.should_receive(:params).and_return({"invoice" => invoice.id})
+    note.should_receive(:status).and_return('Error')
+    note.should_receive(:complete?).and_return false
+    flexmock(invoice).should_receive(:save)
+    Ipn.process(note)
+    assert_equal(note, invoice.ipn)
+  end
+  def test_process
+    email = 'test@invoice.ch'
+    invoice = Business::Invoice.new
+    invoice.yus_name = email
+    item = invoice.add :poweruser, "unlimited access", 365, "Tage", 2
+    invoice.save
+
+    note = flexmock('notification')
+    note.should_receive(:params).and_return({"invoice" => invoice.id})
+    note.should_receive(:status).and_return('Completed')
+    note.should_receive(:complete?).and_return true
+
+    flexmock(Ydim).should_receive(:inject)\
+      .with(invoice, {:payment_received => true})
+    flexmock(Mail).should_receive(:notify_invoice).with(invoice)
+    ODDB.config.auth_domain = 'org.oddb.de'
+    yus = flexmock(Util::Yus)
+    yus.should_receive(:set_preference)\
+      .with(email, 'poweruser_duration', 365)
+    yus.should_receive(:grant).with(email, 'login', 'org.oddb.de.PowerUser')
+    yus.should_receive(:grant).and_return { |yus_name, action, area, time| 
+      assert_equal email, yus_name
+      assert_equal 'view', action
+      assert_equal 'org.oddb.de', area
+      day = Time.now + (60 * 60 * 24 * 365)
+      assert_equal day.year, time.year
+      assert_equal day.month, time.month
+      assert_equal day.day, time.day, 'test always fails around midnight'
+    }
+    flexmock(invoice).should_receive(:save)
+    Ipn.process(note)
+    assert_equal('completed', invoice.status)
+  end
+  def test_process_invoice
+    email = 'test@invoice.ch'
+    invoice = Business::Invoice.new
+    invoice.yus_name = email
+    item = invoice.add :poweruser, "unlimited access", 365, "Tage", 2
+    flexmock(Ydim).should_receive(:inject)\
+      .with(invoice, {:payment_received => true})
+    flexmock(Mail).should_receive(:notify_invoice).with(invoice)
+    ODDB.config.auth_domain = 'org.oddb.de'
+    yus = flexmock(Util::Yus)
+    yus.should_receive(:set_preference)\
+      .with(email, 'poweruser_duration', 365)
+    yus.should_receive(:grant).with(email, 'login', 'org.oddb.de.PowerUser')
+    yus.should_receive(:grant).and_return { |yus_name, action, area, time| 
+      assert_equal email, yus_name
+      assert_equal 'view', action
+      assert_equal 'org.oddb.de', area
+      day = Time.now + (60 * 60 * 24 * 365)
+      assert_equal day.year, time.year
+      assert_equal day.month, time.month
+      assert_equal day.day, time.day, 'test always fails around midnight'
+    }
+    Ipn.process_invoice(invoice)
+  end
+  def test_process_item__poweruser
+    email = 'test@invoice.ch'
+    invoice = Business::Invoice.new
+    invoice.yus_name = email
+    item = invoice.add :poweruser, "unlimited access", 365, "Tage", 2
+    ODDB.config.auth_domain = 'org.oddb.de'
+    yus = flexmock(Util::Yus)
+    yus.should_receive(:set_preference)\
+      .with(email, 'poweruser_duration', 365)
+    yus.should_receive(:grant).with(email, 'login', 'org.oddb.de.PowerUser')
+    yus.should_receive(:grant).and_return { |yus_name, action, area, time| 
+      assert_equal email, yus_name
+      assert_equal 'view', action
+      assert_equal 'org.oddb.de', area
+      day = Time.now + (60 * 60 * 24 * 365)
+      assert_equal day.year, time.year
+      assert_equal day.month, time.month
+      assert_equal day.day, time.day, 'test always fails around midnight'
+    }
+    Ipn.process_item(invoice, item)
+  end
+end
+  end
+end

data/test/util/test_mail.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# Util::TestMail -- de.oddb.org -- 06.02.2007 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/business/invoice'
+require 'oddb/util/mail'
+require 'flexmock'
+
+module ODDB
+  module Util
+class TestMail < Test::Unit::TestCase
+  include FlexMock::TestCase
+  def setup
+    @config = ODDB.config
+    @config.mail_invoice_from = "IPN <ipn@oddb.org>"
+    @config.mail_invoice_smtp = "ipn@oddb.org"
+  end
+  def test_notify_admins
+    @config.admins = ['admin1@ywesee.com', 'admin2@ywesee.com']
+    smtp = flexmock('SMTP')
+    flexstub(Net::SMTP).should_receive(:new).with('localhost')\
+      .times(1).and_return(smtp)
+    smtp.should_receive(:start).times(1).and_return { |blk|
+      smtp.should_receive(:sendmail)\
+        .with(String, 'update@oddb.org', 'admin1@ywesee.com')\
+        .times(1).and_return { assert(true) }
+      smtp.should_receive(:sendmail)\
+        .with(String, 'update@oddb.org', 'admin2@ywesee.com')\
+        .times(1).and_return { assert(true) }
+      blk.call
+    }
+    Mail.notify_admins('Test-Mail', 
+                       [ "This test-mail was sent from",
+                         sprintf("%s:%s", __FILE__, __LINE__),
+                         "TestMail#test_notify_admins"])
+  end
+  def test_notify_invoice
+    invoice = Business::Invoice.new
+    invoice.yus_name = 'test@invoice.com'
+    invoice.add(:poweruser, "unlimited access", 365, "Tage", 2)
+    yus = flexmock(Util::Yus)
+    yus.should_receive(:get_preferences)\
+      .with('test@invoice.com', :salutation, :name_last).and_return {
+      { :salutation => "salutation_m", :name_last => "Tester" }
+    }
+    @config.debug_recipients = [
+    'admin1@ywesee.com', 'admin2@ywesee.com']
+    expected = <<-EOS
+To: test@invoice.com
+From: IPN <ipn@oddb.org>
+Subject: Power-User bei ODDB.org
+Content-Type: text/plain; charset=utf8
+
+Guten Tag Herr Tester
+
+Die Bezahlung für Ihren Power-User-Account konnte erfolgreich abgewickelt werden.
+
+Um während 365 Tagen uneingeschränkt Abfragen tätigen zu können, melden sie sich bitte unter http://ch.oddb.org/de/drugs/login/ an.
+    EOS
+    smtp = flexmock('SMTP')
+    flexstub(Net::SMTP).should_receive(:new).with('localhost')\
+      .times(1).and_return(smtp)
+    smtp.should_receive(:start).times(1).and_return { |blk|
+      smtp.should_receive(:sendmail)\
+        .with(String, 'ipn@oddb.org', 'test@invoice.com')\
+        .times(1).and_return { |body, _, _|
+        assert_match(/^Date: (Mon|Tue|Wed|Thu|Fri|Sat|Sun)/, body)
+        body.sub!(/^Date:.*$\n/, '')
+        assert_equal expected, body
+       }
+      smtp.should_receive(:sendmail)\
+        .with(String, 'ipn@oddb.org', 'admin1@ywesee.com')\
+        .times(1).and_return { assert(true) }
+      smtp.should_receive(:sendmail)\
+        .with(String, 'ipn@oddb.org', 'admin2@ywesee.com')\
+        .times(1).and_return { assert(true) }
+      blk.call
+    }
+    Mail.notify_invoice(invoice)
+  end
+end
+  end
+end

data/test/util/test_multilingual.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+# TestMultilingual -- de.oddb.org -- 05.09.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/util/multilingual'
+require 'encoding/character/utf-8'
+
+module ODDB
+  module Util
+    class TestMultiLingual < Test::Unit::TestCase
+      def setup
+        @ml = Multilingual.new
+      end
+      def test_canonical_reader
+        assert_equal(nil, @ml.de)
+        assert_equal(nil, @ml.fr)
+        @ml.canonical.store(:de, 'Ein Test')
+        assert_equal('Ein Test', @ml.de)
+        assert_equal(nil, @ml.fr)
+        @ml.canonical.store(:fr, 'Un Test')
+        assert_equal('Ein Test', @ml.de)
+        assert_equal('Un Test', @ml.fr)
+      end
+      def test_canonical_writer
+        assert_equal({}, @ml.canonical)
+        @ml.de = 'Ein Test'
+        assert_equal({:de => 'Ein Test'}, @ml.canonical)
+        @ml.fr = 'Un Test'
+        assert_equal({:de => 'Ein Test', :fr => 'Un Test'}, @ml.canonical)
+      end
+      def test_method_missing
+        assert_raises(NoMethodError) { @ml.foo }
+      end
+      def test_equals__canonical
+        assert_equal(false, @ml == nil)
+        assert_equal(false, @ml == 'test')
+        assert_equal(false, @ml == 'tset')
+        @ml.de = "test"
+        assert_equal(false, @ml == nil)
+        assert_equal(true, @ml == 'test')
+        assert_equal(false, @ml == 'tset')
+      end
+      def test_equals__canonical__ustr
+        assert_equal(false, @ml == nil)
+        assert_equal(false, @ml == u('test'))
+        assert_equal(false, @ml == u('tset'))
+        @ml.de = "test"
+        assert_equal(false, @ml == nil)
+        assert_equal(true, @ml == u('test'))
+        assert_equal(false, @ml == u('tset'))
+        @ml.de = u("test")
+        assert_equal(false, @ml == nil)
+        assert_equal(true, @ml == u('test'))
+        assert_equal(false, @ml == u('tset'))
+      end
+      def test_equals__canonical__other_ml
+        ml = Multilingual.new
+        assert_equal(true, @ml == ml)
+        ml.de = 'test'
+        assert_equal(false, @ml == ml)
+        ml.de = 'tset'
+        assert_equal(false, @ml == ml)
+        ml = Multilingual.new
+        @ml.de = "test"
+        assert_equal(false, @ml == ml)
+        ml.de = 'test'
+        assert_equal(true, @ml == ml)
+        ml.de = 'tset'
+        assert_equal(false, @ml == ml)
+        @ml.de = "test"
+      end
+      def test_equals__synonym
+        assert_equal(false, @ml == nil)
+        assert_equal(false, @ml == 'test')
+        assert_equal(false, @ml == 'tset')
+        @ml.synonyms.push("test")
+        assert_equal(false, @ml == nil)
+        assert_equal(true, @ml == 'test')
+        assert_equal(false, @ml == 'tset')
+      end
+      def test_all
+        @ml.de = "de-value"
+        assert_equal(['de-value', 'devalue'], @ml.all)
+        @ml.fr = "fr-value"
+        assert_equal(['de-value', 'devalue', 'fr-value', 'frvalue'], @ml.all.sort)
+        @ml.synonyms.push('synonym')
+        assert_equal(['de-value', 'devalue', 'fr-value', 'frvalue', 'synonym'], @ml.all.sort)
+      end
+      def test_find
+        @ml.de = 'test'
+        assert_equal(@ml, [@ml].find { |elm| elm == 'test'})
+      end
+    end
+  end
+end