ramaze.ch.oddb.org 1.0.0

data/test/selenium/unit.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+# Selenium::TestCase -- de.oddb.org -- 21.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+ENV['LD_LIBRARY_PATH'] = '/usr/local/firefox'
+
+$log_level = 0
+
+if(pid = Kernel.fork)
+  at_exit {
+    Process.kill('HUP', pid)
+    $selenium.stop if($log_level == 0 && $selenium.respond_to?(:stop))
+  }
+else
+  path = File.expand_path('selenium-server.jar', File.dirname(__FILE__))
+  command = $log_level > 0 ? "java -jar #{path}" : "java -jar #{path} &> /dev/null"
+  exec(command) 
+end
+
+require "oddb/config"
+require 'delegate'
+require 'fixes/selenium'
+
+$selenium = ::Selenium::Client::Driver.new :host => "localhost", :port => 4444,
+              :browser => "*chrome", :url => ODDB.config.http_server + ":10080"
+
+start = Time.now
+begin
+  $selenium.start
+rescue Errno::ECONNREFUSED
+  sleep 1
+  if((Time.now - start) > 15)
+    raise
+  else
+    retry
+  end
+end
+
+require "oddb/util/server"
+require 'flexmock'
+require 'logger'
+require 'stub/http_server'
+require "test/unit"
+
+module ODDB
+  module Selenium
+module TestCase
+  include FlexMock::TestCase
+  include ::Selenium::Client::SeleniumHelper
+  def setup
+    Drugs::ActiveAgent.instances.clear
+    Drugs::Atc.instances.clear
+    Drugs::Composition.instances.clear
+    Drugs::Package.instances.clear
+    Drugs::Part.instances.clear
+    Drugs::Product.instances.clear
+    Drugs::Sequence.instances.clear
+    Drugs::Package.instances.clear
+    Business::Company.instances.clear
+    ODDB.logger = Logger.new($stdout)
+    ODDB.logger.level = Logger::DEBUG
+    @auth = flexmock('authenticator')
+    ODDB.auth = @auth
+    @persistence = flexmock('persistence')
+    ODDB.persistence = @persistence
+    @server = Util::Server.new(@persistence)
+    @server.extend(DRbUndumped)
+    drb_url = "druby://localhost:10081"
+    retriable = true
+    begin
+      @drb_server = DRb.start_service(drb_url, @server) 
+    rescue Errno::EADDRINUSE
+      if retriable
+        retriable = false
+        sleep 1
+        retry
+      else
+        raise
+      end
+    end
+    @http_server = Stub.http_server(drb_url, $log_level)
+    @webrick = Thread.new { @http_server.start }
+    @webrick.abort_on_exception = true
+    @verification_errors = []
+    if $selenium
+      @selenium = $selenium
+    else
+      @selenium = ::Selenium::Client::Driver.new :host => "localhost",
+                    :port => 4444, :browser => "*chrome",
+                    :url => ODDB.config.http_server + ":10080"
+      @selenium.start
+    end
+    @selenium.set_context("info")
+    ODDB::Html::Util::Session.reset_query_limit
+  end
+  def teardown
+    @selenium.stop unless $selenium
+    @http_server.shutdown if @http_server
+    @drb_server.stop_service if @drb_server
+    assert_equal [], @verification_errors
+    super
+  end
+  def login(email, *permissions)
+    user = mock_user email, *permissions
+    @auth.should_receive(:login).and_return(user)
+    open "/de/drugs/login"
+    type "email", email
+    type "pass", "test"
+    click "//input[@name='login_']"
+    wait_for_page_to_load 30
+    user
+  end
+  def login_admin
+    login "test.admin@oddb.org", ['login', 'org.oddb.de.Admin']
+  end
+  def mock_user(email, *permissions)
+    user = flexmock(email)
+    user.should_receive(:allowed?).and_return { |*pair|
+      permissions.include?(pair)
+    }
+    user.should_receive(:name).and_return(email)
+    user.should_receive(:get_preference)
+    user.should_receive(:find_entity).and_return { |email|
+      (@yus_entities ||= {})[email]
+    }
+    user.should_receive(:last_login)
+    user.should_receive(:permissions).and_return(permissions)
+    user.should_ignore_missing
+    user
+  end
+  def setup_package(name="Amantadin by Producer", atccode='N04BB01')
+    product = Drugs::Product.new
+    company = Business::Company.new
+    company.name.de = 'Producer AG'
+    product.company = company
+    company.save
+    sequence = Drugs::Sequence.new
+    sequence.product = product
+    atc = Drugs::Atc.new(atccode)
+    atc.name.de = 'Amantadin'
+    ddd = Drugs::Ddd.new('O')
+    ddd.dose = Drugs::Dose.new(10, 'mg')
+    atc.add_ddd(ddd)
+    sequence.atc = atc
+    composition = Drugs::Composition.new
+    galform = Drugs::GalenicForm.new
+    galform.description.de = 'Tabletten'
+    composition.galenic_form = galform
+    grp = Drugs::GalenicGroup.new('Tabletten')
+    grp.administration = 'O'
+    galform.group = grp
+    sequence.add_composition(composition)
+    substance = Drugs::Substance.new
+    substance.name.de = 'Amantadin'
+    dose = Drugs::Dose.new(100, 'mg')
+    active_agent = Drugs::ActiveAgent.new(substance, dose)
+    composition.add_active_agent(active_agent)
+    package = Drugs::Package.new
+    code = Util::Code.new(:cid, '12345', 'DE')
+    package.add_code(code)
+    code = Util::Code.new(:festbetragsstufe, 3, 'DE')
+    package.add_code(code)
+    code = Util::Code.new(:festbetragsgruppe, 4, 'DE')
+    package.add_code(code)
+    code = Util::Code.new(:zuzahlungsbefreit, true, 'DE')
+    package.add_code(code)
+    part = Drugs::Part.new
+    part.package = package
+    part.size = 5
+    part.composition = composition
+    unit = Drugs::Unit.new
+    unit.name.de = 'Ampullen'
+    part.unit = unit
+    part.quantity = Drugs::Dose.new(20, 'ml')
+    package.name.de = name
+    package.sequence = sequence
+    package.add_price(Business::Price.new(:public, 'DE', 6))
+    package.add_price(Business::Price.new(:festbetrag, 'DE', 10))
+    package.save
+    package
+  end
+end
+  end
+end

data/test/stub/http_server.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+# Stub.http_server -- de.oddb.org -- 21.11.2006 -- hwyss@ywesee.com
+
+require 'sbsm/request'
+require 'sbsm/trans_handler'
+require 'webrick'
+
+class Object
+  def meta_class; class << self; self; end; end
+  def meta_eval &blk; meta_class.instance_eval &blk; end
+end
+
+## compatibility-brainfuck for integrating Apache-SBSM-Requests with WEBrick
+module ODDB
+  module Stub
+    class Notes < Hash
+      alias :add :store 
+    end
+    class Output < String
+      alias :write :<<
+      alias :print :<<
+    end
+    class HTTPServer < WEBrick::HTTPServer
+      attr_accessor :document_root, :redirected_output, :attachment
+      def method_missing(method, *args, &block)
+        @logger.warn "ignoring method: #{method}"
+      end
+    end
+    def Stub.http_server(drburi, log_level=0)
+      doc = File.expand_path('../../doc', File.dirname(__FILE__))
+      logger = WEBrick::Log.new
+      logger.level = log_level
+      config = { :Host => 'localhost', :Port => 10080, 
+        :DocumentRoot => doc, :Logger => logger }
+      if(log_level == 0)
+        config.store(:AccessLog, [])
+      end
+      server = HTTPServer.new(config)
+      server.document_root = doc
+      application = Proc.new { |req, resp| 
+        ## this works around a bug where some POST requests were left hanging
+        #  due to an Errno::EAGAIN
+        #  Resource temporarily unavailable - <STDIN>
+        #  see also http://trac.ywesee.com/ticket/1#comment:19
+        #  and subsequent comments
+        data = StringIO.new('')
+        data << req.request_line
+        req.raw_header.each do |line|
+          unless line == req.request_line
+            data << line
+          end
+        end
+        if body = req.body
+          data << "\n" << body << "\n"
+        end
+        data.rewind
+        $stdin = data
+        ##
+        begin
+        if(req.uri == '/favicon.ico')
+          resp.body = File.open(File.join(doc, req.uri))
+        else
+          ARGV.push('')
+          req.server = server
+          req.uri = CGI.unescape(req.uri)
+          SBSM::ZoneTransHandler.instance.translate_uri(req)
+          ## not Threadsafe!
+          SBSM::Apache.request = req
+          output = Output.new
+          ENV.store 'CONTENT_LENGTH', req['content-length'].to_i.to_s
+          sbsm = SBSM::Request.new(drburi)
+          sbsm.meta_eval { define_method(:handle_exception) { |e| raise e } }
+          sbsm.cgi.params.update(req.query)
+          sbsm.cgi.env_table['SERVER_NAME'] = 
+            ODDB.config.http_server.gsub('http://', '') + ':10080'
+          sbsm.cgi.env_table['REQUEST_METHOD'] = req.request_method
+          sbsm.cgi.cookies['_session_id'] = 'test:preset-session-id'
+          sbsm.cgi.output = output
+          sbsm.process
+          if(/^location: http...localhost/i.match(output))
+            resp.status = 303
+          elsif(/^location:.*paypal/i.match(output))
+            req.server.redirected_output = output
+          elsif(!/content-disposition:\s*attachment/i.match(output))
+            req.server.attachment = output
+          end
+          resp.rawdata = true
+          resp.body = output
+        end
+        rescue StandardError, Exception => e
+          ODDB.logger.error e.class.to_s
+          ODDB.logger.error e.message
+          ODDB.logger.error e.backtrace.join("\n")
+        end
+      }
+      server.mount_proc('/', &application)
+      server.mount_proc('/de', &application)
+      server.mount_proc('/de/.*', &application)
+      server.mount('/resources', WEBrick::HTTPServlet::FileHandler, 
+                   File.join(doc, 'resources'), {})
+      server.mount('/captcha', WEBrick::HTTPServlet::FileHandler, 
+                   File.join(ODDB.config.var, 'captcha'), {})
+      server
+    end
+  end
+end
+module WEBrick
+  class HTTPRequest
+    attr_accessor :server, :uri, :notes
+    alias :__old_initialize__ :initialize
+    def initialize(*args)
+      __old_initialize__(*args)
+      @notes = ODDB::Stub::Notes.new
+    end
+    def headers_in
+      headers = {}
+      if(@header)
+        @header.each { |key, vals| headers.store(key, vals.join(';')) }
+      end
+      headers
+    end
+    def uri
+      @uri || unparsed_uri
+    end
+  end
+  class HTTPResponse
+    attr_accessor :rawdata
+    alias :__old_send_header__ :send_header
+    def send_header(socket)
+      if(@rawdata)
+        _write_data(socket, status_line)
+      else
+        __old_send_header__(socket)
+      end
+    end
+    alias :__old_setup_header__ :setup_header
+    def setup_header()
+      unless(@rawdata)
+        __old_setup_header__
+      end
+    end
+  end
+end
+module SBSM
+  class Request
+    def handle_exception(e)
+      raise e
+    end
+    def remote_host(*args)
+      "127.0.0.1"
+    end
+  end
+  module Apache
+    DECLINED = nil
+    def Apache.request=(request)
+      @request = request
+    end
+    def Apache.request
+      @request
+    end
+  end
+end
+class CGI
+  attr_accessor :output
+  def stdoutput
+    output
+  end
+  public :env_table
+end

data/test/stub/model.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+# Model -- de.oddb.org -- 17.11.2006 -- hwyss@ywesee.com
+
+require 'oddb/drugs'
+require 'oddb/business/company'
+require 'oddb/util/code'
+
+class Object
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+end
+module ODDB
+  class Model
+    class << self
+      def all(&block)
+        if(block)
+          instances.each(&block)
+        else
+          instances
+        end
+      end
+      def simulate_database(*names)
+        meta_eval {
+          define_method(:instances) {
+            @instances ||= []
+          }
+          define_method(:find_by_code) { |criteria|
+            thing = instances.find { |instance| instance.codes.any? { |code| 
+              code == criteria } }
+          }
+          define_method(:search_by_code) { |criteria|
+            thing = instances.select { |instance| instance.codes.any? { |code| 
+              code == criteria } }
+          }
+          names.each { |name|
+            define_method("find_by_#{name}") { |nme|
+              instances.find { |instance| instance.send(name) == nme }
+            }
+            define_method("search_by_#{name}") { |nme|
+              instances.select { |instance| 
+                if(instance.respond_to?(name))
+                  /^#{nme}/i.match(instance.send(name).to_s)
+                end
+              }
+            }
+            define_method("search_by_exact_#{name}") { |nme|
+              instances.select { |instance| 
+                nme.downcase == instance.send(name).to_s.downcase
+              }
+            }
+          }
+        }
+        define_method(:save) {
+          @saved = true
+          self.class.instances.push(self).uniq!
+          self
+        }
+        define_method(:delete) {
+          self.class.instances.delete(self)
+          self.class.connections.each { |name|
+            method = "remove_#{self.class.singular}"
+            conn = instance_variable_get(name)
+            if conn.respond_to?(method)
+              conn.send(method, self) 
+            end
+          }
+          checkout
+          super()
+        }
+      end
+      def find_by_uid(uid)
+        ObjectSpace._id2ref(uid.to_i)
+      end
+      def index_keys(name, *keys)
+        meta_eval {
+          define_method(name) { |*args| keys }
+        }
+      end
+    end
+    alias :uid :object_id
+    attr_accessor :saved
+    def checkout
+    end
+    def saved?
+      @saved
+    end
+    #unless(instance_methods.include?('__stub_to_yaml_properties__'))
+    #  alias :__stub_to_yaml_properties__ :to_yaml_properties
+      def to_yaml_properties
+        super - [:@saved]
+    #    __stub_to_yaml_properties__ - ['@saved']
+      end
+    #end
+  end
+  module Business
+    class Company < Model
+      simulate_database(:name)
+    end
+    class Invoice < Model
+      simulate_database(:yus_name, :id)
+    end
+  end
+  module Drugs
+    class ActiveAgent < Model
+      simulate_database
+    end
+    class Atc < Model
+      simulate_database(:name)
+      class << self
+        def find_by_code(code)
+          @instances.find { |inst| inst.code == code }
+        end
+        def search_by_level_and_code(level, code)
+          @instances.select { |inst| 
+            inst.level == level && inst.code[0,code.length] == code }
+        end
+      end
+    end
+    class Composition < Model
+      simulate_database
+      def checkout
+        Sequence.all { |seq| seq.remove_composition self }
+      end
+    end
+    class GalenicForm < Model
+      simulate_database(:description)
+    end
+    class GalenicGroup < Model
+      simulate_database(:name)
+    end
+    class Package < Model
+      simulate_database(:name, :atc, :substance, :company, :product)
+      def self.count
+        instances.size
+      end
+    end
+    class Part < Model
+      simulate_database
+      def checkout
+        Package.all { |pac| pac.remove_part self }
+      end
+    end
+    class Product < Model
+      simulate_database(:name)
+      index_keys(:name_keys, 'a', '4')
+    end
+    class Sequence < Model
+      simulate_database(:product)
+    end
+    class Substance < Model
+      simulate_database(:name)
+    end
+    class SubstanceGroup < Model
+      simulate_database(:name)
+    end
+    class Unit < Model
+      simulate_database(:name)
+    end
+  end
+  module Util
+    class Feedback < Model
+      simulate_database 
+    end
+    class M10lDocument < Model
+    end
+  end
+  module Text
+    class Document < Model
+      simulate_database(:source)
+    end
+  end
+  Currency = Object.new
+end