edgeway 0.2.0 → 0.3.0

data/lib/edgeway/cache/limits.rb

@@ -0,0 +1,8 @@
+module Edgeway
+  module Cache
+    # A year. In wasm, Integers are 32 bits: epoch seconds plus an expires_in
+    # stop fitting in 2038, so a longer expiry is refused rather than allowed
+    # to overflow.
+    MAX_EXPIRES_IN = 31_536_000
+  end
+end

data/lib/edgeway/cache/memory_store.rb

@@ -0,0 +1,24 @@
+require_relative "store"
+
+module Edgeway
+  module Cache
+    class MemoryStore < Store
+      def initialize(namespace: nil, expires_in: nil)
+        super(namespace: namespace, expires_in: expires_in)
+        @texts = {}
+      end
+
+      def read_text(key) = @texts[key]
+
+      def write_text(key, text, expires_in_seconds)
+        @texts[key] = text
+        true
+      end
+
+      def delete_text(key)
+        @texts.delete(key)
+        true
+      end
+    end
+  end
+end

data/lib/edgeway/cache/null_store.rb

@@ -0,0 +1,13 @@
+require_relative "store"
+
+module Edgeway
+  module Cache
+    class NullStore < Store
+      def read_text(key) = nil
+
+      def write_text(key, text, expires_in_seconds) = true
+
+      def delete_text(key) = true
+    end
+  end
+end

data/lib/edgeway/cache/store.rb

@@ -0,0 +1,189 @@
+require_relative "limits"
+
+module Edgeway
+  module Cache
+    MAX_KEY_BYTES = 512
+    KEY_DIGEST_LENGTH = 64
+
+    def self.utf8?(text) = text.dup.force_encoding("UTF-8").valid_encoding?
+
+    class Store
+      def initialize(namespace: nil, expires_in: nil)
+        @namespace = namespace.nil? ? "" : namespace.dup.force_encoding("UTF-8")
+        @default_expires_in = expires_in.nil? ? 0 : checked_expires_in(expires_in)
+      end
+
+      def read(key)
+        entry = lookup(key)
+        entry.nil? ? nil : entry["v"]
+      end
+
+      def exist?(key) = !lookup(key).nil?
+
+      def write(key, value, expires_in: nil)
+        seconds = expires_in_seconds(expires_in)
+        check_cacheable(value)
+        write_text(expand_key(key), envelope(value, seconds), seconds)
+      end
+
+      def fetch(key, expires_in: nil, force: false, skip_nil: false)
+        unless block_given?
+          raise ArgumentError, "missing block" if force
+
+          return read(key)
+        end
+
+        unless force
+          entry = lookup(key)
+          return entry["v"] unless entry.nil?
+        end
+        value = yield
+        write(key, value, expires_in: expires_in) unless skip_nil && value.nil?
+        value
+      end
+
+      def delete(key) = delete_text(expand_key(key))
+
+      def read_text(key)
+        raise Edgeway::Error, "#{self.class.name} does not read"
+      end
+
+      def write_text(key, text, expires_in_seconds)
+        raise Edgeway::Error, "#{self.class.name} does not write"
+      end
+
+      def delete_text(key)
+        raise Edgeway::Error, "#{self.class.name} does not delete"
+      end
+
+      private
+
+      def current_time = Time.now.to_i
+
+      def lookup(key)
+        text = read_text(expand_key(key))
+        return nil if text.nil?
+
+        entry = parse_entry(text)
+        return nil if entry.nil? || expired?(entry)
+
+        entry
+      end
+
+      def parse_entry(text)
+        entry = JSON.parse(text)
+        entry.is_a?(Hash) && entry.key?("v") ? entry : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      def expired?(entry)
+        entry["e"].is_a?(Integer) && Integer(entry["e"]) <= current_time
+      end
+
+      def envelope(value, seconds)
+        entry = { "v" => value }
+        entry["e"] = current_time + seconds if seconds > 0
+        JSON.generate(entry)
+      end
+
+      def expires_in_seconds(expires_in)
+        expires_in.nil? ? @default_expires_in : checked_expires_in(expires_in)
+      end
+
+      def checked_expires_in(seconds)
+        unless seconds.is_a?(Integer) && Integer(seconds) > 0 && Integer(seconds) <= MAX_EXPIRES_IN
+          raise ArgumentError, "expires_in must be a whole number of seconds, 1 to #{MAX_EXPIRES_IN}"
+        end
+
+        seconds
+      end
+
+      def check_cacheable(value)
+        if value.is_a?(String)
+          check_text(value)
+        elsif value.is_a?(Array)
+          value.each { |item| check_cacheable(item) }
+        elsif value.is_a?(Hash)
+          check_hash(value)
+        elsif value.is_a?(Float)
+          raise ArgumentError, "a Float to cache must be finite" unless Float(value).finite?
+        elsif !json_scalar?(value)
+          raise ArgumentError, "#{value.class.name} can't be cached (String, Integer, Float, true, false, nil, Array and Hash can)"
+        end
+      end
+
+      def check_text(text)
+        raise ArgumentError, "a String to cache must be valid UTF-8 (a binary String is not)" unless Cache.utf8?(text)
+      end
+
+      def check_hash(hash)
+        names = {}
+        hash.each do |name, item|
+          unless name.is_a?(String) || name.is_a?(Symbol)
+            raise ArgumentError, "a Hash to cache needs String or Symbol keys (got #{name.class.name})"
+          end
+          raise ArgumentError, "a Hash to cache has the same key twice (as a String and a Symbol)" if names.key?(name.to_s)
+
+          names[name.to_s] = true
+          check_cacheable(name.to_s)
+          check_cacheable(item)
+        end
+      end
+
+      def json_scalar?(value) = value.nil? || value == true || value == false || value.is_a?(Integer)
+
+      def expand_key(key)
+        text = key_text(key)
+        raise ArgumentError, "cache key can't be blank" if text.empty?
+
+        text = "#{@namespace}:#{text}" unless @namespace.empty?
+        check_key_text(text)
+        text.bytesize > MAX_KEY_BYTES ? shortened(text) : text
+      end
+
+      def check_key_text(text)
+        raise ArgumentError, "cache key must be valid UTF-8" unless Cache.utf8?(text)
+        raise ArgumentError, "cache key can't contain a NUL byte" if text.include?("\0")
+      end
+
+      def key_text(key)
+        if key.is_a?(Edgeway::Model::Base)
+          model_key(key)
+        elsif key.is_a?(Array)
+          key.map { |part| key_text(part) }.join("/")
+        elsif key.is_a?(String)
+          utf8_key_part(key)
+        elsif key.is_a?(Symbol) || key.is_a?(Integer)
+          key.to_s
+        else
+          raise ArgumentError, "a cache key is a String, Symbol, Integer, model or an Array of them (got #{key.class.name})"
+        end
+      end
+
+      def utf8_key_part(part)
+        raise ArgumentError, "cache key must be valid UTF-8" unless Cache.utf8?(part)
+
+        part.dup.force_encoding("UTF-8")
+      end
+
+      def model_key(model)
+        updated_at = model.as_json["updated_at"].to_s
+        raise ArgumentError, "#{model.class.name} has no updated_at (add timestamps)" if updated_at.empty?
+
+        "#{model.class.table_name}/#{model.id}-#{updated_at}"
+      end
+
+      def shortened(text)
+        prefix_bytes = MAX_KEY_BYTES - KEY_DIGEST_LENGTH - 1
+        prefix = +""
+        text.each_char do |character|
+          break if prefix.bytesize + character.bytesize > prefix_bytes
+
+          prefix << character
+        end
+        "#{prefix}:#{Digest::SHA256.hexdigest(text)}"
+      end
+    end
+  end
+end

data/lib/edgeway/cache.rb

@@ -0,0 +1,13 @@
+require_relative "cache/store"
+require_relative "cache/null_store"
+require_relative "cache/memory_store"
+
+module Edgeway
+  @cache = Cache::NullStore.new
+
+  def self.cache = @cache
+
+  def self.cache=(store)
+    @cache = store
+  end
+end

data/lib/edgeway/cli/build/cache_config.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "../../cache/limits"
+
+module Edgeway
+  module CLI
+    class Build
+      class CacheConfig
+        STORES = {
+          "kv" => "edgeway/service/cloudflare/kv",
+          "memory" => nil,
+          "null" => nil
+        }.freeze
+        KEYS = %w[store binding namespace expires_in].freeze
+
+        attr_reader :store, :binding_name, :namespace, :expires_in
+
+        def self.load(root, env)
+          path = File.join(root, "config", "cache.yml")
+          return new("null") unless File.exist?(path)
+
+          sections = YAML.safe_load_file(path) || {}
+          raise Error, "config/cache.yml must be a Hash of environments" unless sections.is_a?(Hash)
+
+          section = sections[env]
+          return new("null") if section.nil?
+          raise Error, "config/cache.yml: #{env} must be a Hash" unless section.is_a?(Hash)
+
+          from_section(section, env)
+        end
+
+        def self.from_section(section, env)
+          unknown = section.keys.map(&:to_s) - KEYS
+          raise Error, "config/cache.yml: unknown #{unknown.join(", ")} in #{env} (one of #{KEYS.join(", ")})" unless unknown.empty?
+
+          new(store_name(section), binding_name: section["binding"], namespace: section["namespace"],
+                               expires_in: section["expires_in"], env: env)
+        end
+
+        def self.store_name(section)
+          section.key?("store") && section["store"].nil? ? "null" : section["store"]
+        end
+
+        def initialize(store, binding_name: nil, namespace: nil, expires_in: nil, env: "development")
+          @env = env
+          @store = checked_store(store)
+          @binding_name = checked_binding(binding_name)
+          @namespace = checked_namespace(namespace)
+          @expires_in = checked_expires_in(expires_in)
+        end
+
+        def backend_file = STORES.fetch(@store)
+
+        def store_expression
+          case @store
+          when "kv" then kv_expression
+          when "memory" then "Edgeway::Cache::MemoryStore.new(#{store_options})"
+          else "Edgeway::Cache::NullStore.new"
+          end
+        end
+
+        private
+
+        def store_options = "namespace: #{@namespace.inspect}, expires_in: #{@expires_in.inspect}"
+
+        def kv_expression
+          "Edgeway::Cloudflare::KVStore.new(binding: #{@binding_name.inspect}, #{store_options}, " \
+            "transport: Edgeway::Cloudflare::KVImportTransport.new)"
+        end
+
+        def checked_store(store)
+          return store if STORES.key?(store)
+
+          raise Error, "config/cache.yml: store in #{@env} must be one of #{STORES.keys.join(", ")} (got #{store.inspect})"
+        end
+
+        def checked_binding(binding_name)
+          return checked_unused_binding(binding_name) unless @store == "kv"
+          raise Error, "config/cache.yml: binding: in #{@env} must be a String" unless binding_name.nil? || binding_name.is_a?(String)
+          return binding_name unless binding_name.nil? || binding_name.empty?
+
+          raise Error, "config/cache.yml: #{@env} has store: kv but no binding: (the name of a [[kv_namespaces]] binding in wrangler.toml)"
+        end
+
+        def checked_unused_binding(binding_name)
+          raise Error, "config/cache.yml: binding: is only for store: kv (in #{@env})" unless binding_name.nil?
+
+          nil
+        end
+
+        def checked_namespace(namespace)
+          return nil if namespace.nil?
+          raise Error, "config/cache.yml: namespace in #{@env} must be a non-empty String" unless namespace.is_a?(String) && !namespace.empty?
+          return namespace if namespace.valid_encoding? && !namespace.include?("\0")
+
+          raise Error, "config/cache.yml: namespace in #{@env} must be valid UTF-8 without a NUL byte"
+        end
+
+        def checked_expires_in(seconds)
+          return nil if seconds.nil?
+          return seconds if seconds.is_a?(Integer) && seconds.between?(1, Edgeway::Cache::MAX_EXPIRES_IN)
+
+          raise Error, "config/cache.yml: expires_in in #{@env} must be a whole number of seconds, 1 to #{Edgeway::Cache::MAX_EXPIRES_IN}"
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/cli/build/database_config.rb

@@ -17,6 +17,10 @@ module Edgeway
           section
         end
 
+        def section?(env)
+          File.exist?(path) && sections[env].is_a?(Hash)
+        end
+
         def databases_in(section, env)
           entries = section["databases"] || {}
           raise Error, "config/database.yml: databases in #{env} must be a Hash" unless entries.is_a?(Hash)

data/lib/edgeway/cli/build/js_files.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Edgeway
+  module CLI
+    class Build
+      module JsFiles
+        TEST_ONLY = /-test(-[^\/]*)?\.js\z/
+
+        def self.copy(destination, config_js, tests: false)
+          FileUtils.mkdir_p(destination)
+          paths(tests).each { |file| FileUtils.cp(file, destination) }
+          File.write(File.join(destination, "config.js"), config_js)
+        end
+
+        def self.paths(tests)
+          files = Dir.glob(File.join(CLI.gem_dir, "js/*.js"))
+          tests ? files : files.grep_v(TEST_ONLY)
+        end
+
+        def self.config_js(values, command)
+          "// Generated by `edgeway #{command}` from config/database.yml; do not edit.\n" \
+            "export default #{JSON.generate(values)};\n"
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/cli/build.rb

@@ -4,6 +4,8 @@ require "optparse"
 require "json"
 require_relative "build/app_config"
 require_relative "build/app_files"
+require_relative "build/cache_config"
+require_relative "build/js_files"
 require_relative "build/view_compiler"
 
 module Edgeway
@@ -16,8 +18,9 @@ module Edgeway
     # Spinel resolves require at compile time and has no autoloading, so
     # build/main.rb requires every file, in an order where a class body finds
     # what it names (a superclass, an extended module):
-    #   1. edgeway, the database adapter config/database.yml names, and the JWT
-    #      verifier
+    #   1. edgeway, the database adapter config/database.yml names, the JWT
+    #      verifier, the HTTP client, the rate limiter and the cache store
+    #      config/cache.yml names (when it needs a file)
     #   2. app/*/ other than models/ and controllers/ (services, ...)
     #   3. app/models/
     #   4. app/controllers/
@@ -57,15 +60,23 @@ module Edgeway
       private
 
       def write_main(config)
+        cache = CacheConfig.load(@root, @env)
         lines = ["# Generated by `edgeway build` from app/ and config/; do not edit.", 'require "edgeway"']
         lines << "require #{config.adapter_file.dump}"
-        # Always: js/cloudflare.js supplies the edgeway_jwt import to every app,
-        # and the verifier is only called by an app that authenticates.
+        # Always: js/cloudflare.js supplies the edgeway_jwt, edgeway_fetch and
+        # edgeway_ratelimit imports to every app, and each is only called by an
+        # app that authenticates, calls out or rate limits.
         lines << 'require "edgeway/service/cloudflare/jwt"'
+        lines << 'require "edgeway/service/fetch"'
+        lines << 'require "edgeway/service/cloudflare/rate_limit"'
+        lines << "require #{cache.backend_file.dump}" if cache.backend_file
         lines << ""
         lines << connection_line(config)
         config.databases.each { |name, binding_name| lines << connect_line(config, name, binding_name) }
         lines << "Edgeway::Auth.verifier = Edgeway::Cloudflare::JWTVerifier.new"
+        lines << "Edgeway::HTTP.client = Edgeway::FetchTransport.new"
+        lines << "Edgeway.cache = #{cache.store_expression}"
+        lines << "Edgeway::Controller.rate_limiter = Edgeway::Cloudflare::RateLimiter.new(transport: Edgeway::Cloudflare::RateLimitImportTransport.new)"
         lines << ""
         views = ViewCompiler.new(@root).compile
         File.write(File.join(@root, "build/views.rb"), views) if views
@@ -91,16 +102,12 @@ module Edgeway
       end
 
       def copy_js(config)
-        dest = File.join(@root, "build/edgeway")
-        FileUtils.mkdir_p(dest)
-        Dir.glob(File.join(CLI.gem_dir, "js/*.js")).each { |f| FileUtils.cp(f, dest) }
-        File.write(File.join(dest, "config.js"), config_js(config))
+        JsFiles.copy(File.join(@root, "build/edgeway"), config_js(config))
       end
 
       def config_js(config)
         values = { "env" => config.env, "d1Binding" => config.binding_name, "sessions" => config.sessions }
-        "// Generated by `edgeway build` from config/database.yml; do not edit.\n" \
-          "export default #{JSON.generate(values)};\n"
+        JsFiles.config_js(values, "build")
       end
 
       def compile

data/lib/edgeway/cli/cloudflare_test/wasm_test_cli.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Edgeway
+  module CLI
+    class CloudflareTest
+      class WasmTestCLI < SpinelTest::Unit::CLI
+        def initialize(argv, root:, launcher:)
+          super(argv, root: root)
+          @launcher = launcher
+        end
+
+        private
+
+        def compile(spinel, main, bin, entries)
+          wasm = File.join(@root, "tmp/test_app.wasm")
+          command = [spinel, "--target=wasm32-wasi", "--incremental"] +
+                    include_dirs(entries).flat_map { |directory| ["-I", directory] } + [main, "-o", wasm]
+          output, status = Open3.capture2e(*command)
+          unless status.success?
+            warn output unless output.empty?
+            warn "edgeway test: compilation failed (#{command.join(" ")})"
+            return false
+          end
+          write_launcher(bin, wasm)
+        end
+
+        def write_launcher(bin, wasm)
+          File.write(bin, "#!/bin/sh\nexec #{Shellwords.join(@launcher + [wasm])} \"$@\"\n")
+          File.chmod(0o755, bin)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/edgeway/cli/cloudflare_test.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require "open3"
+
+module Edgeway
+  module CLI
+    class CloudflareTest < Test
+      RUNTIME_DIR = "tmp/edgeway"
+      RUNNER = "cloudflare-test-runner.js"
+      MIN_NODE_MAJOR = 24
+
+      # The apps whose test environment uses the d1 adapter.
+      def self.handles?(database)
+        database.section?("test") && database.section("test")["adapter"] == "d1"
+      end
+
+      def initialize(root)
+        super
+        @config = Build::AppConfig.load(root, "test")
+      end
+
+      def run(args)
+        check_prerequisites
+        write_test_app
+        write_runtime
+        require_spinel_test_unit
+        argv = ["-I", @root, "-I", CLI.gem_dir + "/lib", *args]
+        exit WasmTestCLI.new(argv, root: @root, launcher: launcher).run
+      end
+
+      private
+
+      def database_lines
+        [
+          'require "edgeway/db/memory"',
+          'require "edgeway/service/cloudflare/test_databases"',
+          'require "edgeway/service/cloudflare/jwt"',
+          'require "edgeway/service/fetch"',
+          "module Edgeway; TEST_DATABASES = #{@config.databases.keys.inspect}; end",
+          "module Edgeway; TEST_BINDINGS = #{bindings.inspect}; end"
+        ]
+      end
+
+      def bindings
+        { "primary" => @config.binding_name }.merge(@config.databases)
+      end
+
+      def migration_directories
+        { "primary" => "db/migrations" }.merge(@config.databases.to_h { |name, _binding| [name, "db/#{name}/migrations"] })
+      end
+
+      def write_runtime
+        databases = bindings.map do |name, binding_name|
+          { "binding" => binding_name, "migrations" => File.join(@root, migration_directories.fetch(name)) }
+        end
+        values = {
+          "env" => "test", "d1Binding" => @config.binding_name, "sessions" => @config.sessions,
+          "appRoot" => @root, "databases" => databases
+        }
+        directory = File.join(@root, RUNTIME_DIR)
+        Build::JsFiles.copy(directory, Build::JsFiles.config_js(values, "test"), tests: true)
+        File.write(File.join(directory, "package.json"), %({"type": "module"}\n))
+      end
+
+      def launcher
+        ["node", *node_flags, File.join(@root, RUNTIME_DIR, RUNNER)]
+      end
+
+      def node_flags
+        has_jspi = system("node", "-e", "process.exit(typeof WebAssembly.Suspending === 'function' ? 0 : 1)")
+        has_jspi ? [] : ["--experimental-wasm-jspi", "--experimental-wasm-exnref"]
+      end
+
+      def require_spinel_test_unit
+        require "spinel_test/unit/cli"
+        require_relative "cloudflare_test/wasm_test_cli"
+      rescue LoadError
+        raise Error, 'spinel_test-unit is not installed (add gem "spinel_test-unit", "~> 0.1", group: :test to the Gemfile and run bundle install)'
+      end
+
+      def check_prerequisites
+        check_node
+        raise Error, "no wrangler.toml in #{@root} (the tests run on the local D1 it describes)" unless File.exist?(File.join(@root, "wrangler.toml"))
+
+        check_wrangler
+        raise Error, "no WASI SDK found (install it with mise, or set WASI_SDK=/path/to/wasi-sdk)" unless Toolchain.wasi_sdk
+        raise Error, "no Spinel compiler found (install it with mise, or set SPINEL=/path/to/spinel)" unless Toolchain.spinel
+
+        check_migration_directories
+      end
+
+      def check_node
+        raise Error, "node is not installed; `edgeway test` runs the tests on the local D1 of wrangler, which needs Node.js #{MIN_NODE_MAJOR} or later" unless Toolchain.find_on_path("node")
+
+        version, = Open3.capture2("node", "-p", "process.versions.node")
+        return if version.to_i >= MIN_NODE_MAJOR
+
+        raise Error, "Node.js #{version.strip} is too old: `edgeway test` needs #{MIN_NODE_MAJOR} or later (WebAssembly JSPI)"
+      end
+
+      def check_wrangler
+        return if File.directory?(File.join(@root, "node_modules/wrangler"))
+
+        raise Error, "wrangler is not installed in #{@root}/node_modules; run #{PackageManager.install} (or bin/setup)"
+      end
+
+      def check_migration_directories
+        @config.databases.each_key do |name|
+          directory = migration_directories.fetch(name)
+          next if File.directory?(File.join(@root, directory))
+
+          raise Error, "database #{name} (config/database.yml) has no #{directory} directory"
+        end
+      end
+    end
+
+    Test::PLATFORMS << CloudflareTest
+  end
+end

data/lib/edgeway/cli/test.rb

@@ -3,34 +3,50 @@
 module Edgeway
   module CLI
     class Test
+      PLATFORMS = []
+
       def self.run(args)
         root = Dir.pwd
-        Precheck.sqlite!
-        new(root).write_test_app
-        exec("spinel_test-unit", "-I", root, "-I", CLI.gem_dir + "/lib", *args)
+        database = Build::DatabaseConfig.new(root)
+        (PLATFORMS.find { |platform| platform.handles?(database) } || Test).new(root).run(args)
       end
 
       def initialize(root)
         @root = root
       end
 
+      def run(args)
+        Precheck.sqlite!
+        write_test_app
+        exec("spinel_test-unit", "-I", @root, "-I", CLI.gem_dir + "/lib", *args)
+      end
+
       def write_test_app
         raise Error, "no config/routes.rb in #{@root}" unless File.exist?(File.join(@root, "config/routes.rb"))
 
         FileUtils.mkdir_p(File.join(@root, "tmp"))
         lines = ["# Generated by `edgeway test` from app/ and config/; do not edit.", 'require "edgeway"']
-        lines << 'require "edgeway/db/memory"'
-        lines << 'require "edgeway/db/sqlite"'
-        # Where the migrations are read from at test time (the binary may run
-        # from another directory); Edgeway::UnitTest#setup applies them.
-        lines << "module Edgeway; TEST_APP_ROOT = #{@root.dump}; end"
-        lines << "module Edgeway; TEST_DATABASES = #{Build::DatabaseConfig.new(@root).names.inspect}; end"
+        lines.concat(database_lines)
         lines << ""
         views = Build::ViewCompiler.new(@root).compile
         File.write(File.join(@root, "tmp/views.rb"), views) if views
         lines.concat(Build::AppFiles.new(@root).require_lines(views: views && "views"))
         File.write(File.join(@root, "tmp/test_app.rb"), lines.join("\n") + "\n")
       end
+
+      private
+
+      def database_lines
+        [
+          'require "edgeway/db/memory"',
+          'require "edgeway/db/sqlite"',
+          'require "edgeway/test/sqlite_databases"',
+          # Where the migrations are read from at test time (the binary may run
+          # from another directory); Edgeway::TestDatabases applies them.
+          "module Edgeway; TEST_APP_ROOT = #{@root.dump}; end",
+          "module Edgeway; TEST_DATABASES = #{Build::DatabaseConfig.new(@root).names.inspect}; end"
+        ]
+      end
     end
   end
 end