hocon 0.9.5 → 1.0.1

data/spec/unit/typesafe/config/hocon_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hocon'
+require 'hocon/config_render_options'
+
+describe Hocon do
+  let(:render_options) { Hocon::ConfigRenderOptions.defaults }
+
+  before do
+    render_options.origin_comments = false
+    render_options.json = false
+  end
+
+  RSpec.shared_examples "hocon_parsing" do
+
+    it "should make the config data available as a map" do
+      expect(conf).to eq(expected)
+    end
+
+  end
+
+  [EXAMPLE1, EXAMPLE2].each do |example|
+    let(:input_file) { "#{FIXTURE_DIR}/parse_render/#{example[:name]}/input.conf" }
+    let(:output_file) { "#{FIXTURE_DIR}/parse_render/#{example[:name]}/output.conf" }
+    let(:output) { File.read("#{output_file}") }
+    let(:output_nocomments_file) { "#{FIXTURE_DIR}/parse_render/#{example[:name]}/output_nocomments.conf" }
+    let(:output_nocomments) { File.read("#{output_nocomments_file}") }
+    let(:expected) { example[:hash] }
+    # TODO 'reparsed' appears to be unused
+    let(:reparsed) { Hocon::ConfigFactory.parse_file("#{FIXTURE_DIR}/parse_render/#{example[:name]}/output.conf") }
+
+    context "loading a HOCON file" do
+      let(:conf) { Hocon.load(input_file) }
+      include_examples "hocon_parsing"
+    end
+
+    context "parsing a HOCON string" do
+      let(:string) { File.open(input_file).read }
+      let(:conf) { Hocon.parse(string) }
+      include_examples "hocon_parsing"
+    end
+
+  end
+
+  context "loading a HOCON file with a substitution" do
+    conf = Hocon.load("#{FIXTURE_DIR}/parse_render/#{EXAMPLE3[:name]}/input.conf")
+    expected = EXAMPLE3[:hash]
+    it "should successfully resolve the substitution" do
+      expect(conf).to eq(expected)
+    end
+  end
+end
+

data/spec/unit/typesafe/config/path_spec.rb

@@ -0,0 +1,261 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hocon'
+require 'test_utils'
+
+
+describe Hocon::Impl::Path do
+  Path = Hocon::Impl::Path
+
+  ####################
+  # Path Equality
+  ####################
+  context "Check path equality" do
+    # note: foo.bar is a single key here
+    let(:key_a) { Path.new_key("foo.bar") }
+    let(:same_as_key_a) { Path.new_key("foo.bar") }
+    let(:different_key) { Path.new_key("hello") }
+
+    # Here foo.bar is two elements
+    let(:two_elements) { Path.new_path("foo.bar") }
+    let(:same_as_two_elements) { Path.new_path("foo.bar") }
+
+    context "key_a equals a path of the same name" do
+      let(:first_object) { key_a }
+      let(:second_object) { TestUtils.path("foo.bar") }
+      include_examples "object_equality"
+    end
+
+    context "two_elements equals a path with those two elements" do
+      let(:first_object) { two_elements}
+      let(:second_object) { TestUtils.path("foo", "bar") }
+      include_examples "object_equality"
+    end
+
+    context "key_a equals key_a" do
+      let(:first_object) { key_a }
+      let(:second_object) { key_a }
+      include_examples "object_equality"
+    end
+
+    context "key_a equals same_as_key_a" do
+      let(:first_object) { key_a }
+      let(:second_object) { same_as_key_a }
+      include_examples "object_equality"
+    end
+
+    context "key_a not equal to different_key" do
+      let(:first_object) { key_a }
+      let(:second_object) { different_key }
+      include_examples "object_inequality"
+    end
+
+    context "key_a not equal to the two_elements path" do
+      let(:first_object) { key_a }
+      let(:second_object) { two_elements }
+      include_examples "object_inequality"
+    end
+
+    context "two_elements path equals same_as_two_elements path" do
+      let(:first_object) { two_elements}
+      let(:second_object) { same_as_two_elements }
+      include_examples "object_equality"
+    end
+  end
+
+  ####################
+  # Testing to_s
+  ####################
+  context "testing to_s" do
+    it "should find to_s returning the correct strings" do
+      expect("Path(foo)").to eq(TestUtils.path("foo").to_s)
+      expect("Path(foo.bar)").to eq(TestUtils.path("foo", "bar").to_s)
+      expect('Path(foo."bar*")').to eq(TestUtils.path("foo", "bar*").to_s)
+      expect('Path("foo.bar")').to eq(TestUtils.path("foo.bar").to_s)
+    end
+  end
+
+  ####################
+  # Render
+  ####################
+  context "testing .render" do
+    context "rendering simple one element case" do
+      let(:expected) { "foo" }
+      let(:path) { TestUtils.path("foo") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering simple two element case" do
+      let(:expected) { "foo.bar" }
+      let(:path) { TestUtils.path("foo", "bar") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering non safe char in an element" do
+      let(:expected) { 'foo."bar*"' }
+      let(:path) { TestUtils.path("foo", "bar*") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering period in an element" do
+      let(:expected) { '"foo.bar"' }
+      let(:path) { TestUtils.path("foo.bar") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering hyphen in element" do
+      let(:expected) { "foo-bar" }
+      let(:path) { TestUtils.path("foo-bar") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering hyphen in element" do
+      let(:expected) { "foo_bar" }
+      let(:path) { TestUtils.path("foo_bar") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering element starting with a hyphen" do
+      let(:expected) { "-foo" }
+      let(:path) { TestUtils.path("-foo") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering element starting with a number" do
+      let(:expected) { "10foo" }
+      let(:path) { TestUtils.path("10foo") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering empty elements" do
+      let(:expected) { '"".""' }
+      let(:path) { TestUtils.path("", "") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering element with internal space" do
+      let(:expected) { '"foo bar"' }
+      let(:path) { TestUtils.path("foo bar") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering leading and trailing spaces" do
+      let(:expected) { '" foo "' }
+      let(:path) { TestUtils.path(" foo ") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering trailing space only" do
+      let(:expected) { '"foo "' }
+      let(:path) { TestUtils.path("foo ") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering number with decimal point" do
+      let(:expected) { "1.2" }
+      let(:path) { TestUtils.path("1", "2") }
+      include_examples "path_render_test"
+    end
+
+    context "rendering number with multiple decimal points" do
+      let(:expected) { "1.2.3.4" }
+      let(:path) { TestUtils.path("1", "2", "3", "4") }
+      include_examples "path_render_test"
+    end
+  end
+
+  context "test that paths made from a list of Path objects equal paths made from a list of strings" do
+    it "should find a path made from a list of one path equal to a path from one string" do
+      path_from_path_list = Path.from_path_list([TestUtils.path("foo")])
+      expected_path = TestUtils.path("foo")
+
+      expect(path_from_path_list).to eq(expected_path)
+    end
+
+    it "should find a path made from a list of multiple paths equal to that list of strings" do
+      path_from_path_list = Path.from_path_list([TestUtils.path("foo", "bar"),
+                                                 TestUtils.path("baz", "boo")])
+      expected_path = TestUtils.path("foo", "bar", "baz", "boo")
+
+      expect(path_from_path_list).to eq(expected_path)
+    end
+  end
+
+  context "prepending paths" do
+    it "should find prepending a single path works" do
+      prepended_path = TestUtils.path("bar").prepend(TestUtils.path("foo"))
+      expected_path = TestUtils.path("foo", "bar")
+
+      expect(prepended_path).to eq(expected_path)
+    end
+
+    it "should find prepending multiple paths works" do
+      prepended_path = TestUtils.path("c", "d").prepend(TestUtils.path("a", "b"))
+      expected_path = TestUtils.path("a", "b", "c", "d")
+
+      expect(prepended_path).to eq(expected_path)
+    end
+  end
+
+  context "path length" do
+    it "should find length of single part path to be 1" do
+      path = TestUtils.path("food")
+      expect(path.length).to eq(1)
+    end
+
+    it "should find length of two part path to be 2" do
+      path = TestUtils.path("foo", "bar")
+      expect(path.length).to eq(2)
+
+    end
+  end
+
+  context "parent paths" do
+    it "should find parent of single level path to be nil" do
+      path = TestUtils.path("a")
+
+      expect(path.parent).to be_nil
+    end
+
+    it "should find parent of a.b to be a" do
+      path = TestUtils.path("a", "b")
+      parent = TestUtils.path("a")
+
+      expect(path.parent).to eq(parent)
+    end
+
+    it "should find parent of a.b.c to be a.b" do
+      path = TestUtils.path("a", "b", "c")
+      parent = TestUtils.path("a", "b")
+
+      expect(path.parent).to eq(parent)
+    end
+  end
+
+  context "path last method" do
+    it "should find last of single level path to be itself" do
+      path = TestUtils.path("a")
+
+      expect(path.last).to eq("a")
+    end
+
+    it "should find last of a.b to be b" do
+      path = TestUtils.path("a", "b")
+
+      expect(path.last).to eq("b")
+    end
+  end
+
+  context "invalid paths" do
+    it "should catch exception from empty path" do
+      bad_path = ""
+      expect { Path.new_path(bad_path) }.to raise_error(Hocon::ConfigError::ConfigBadPathError)
+    end
+
+    it "should catch exception from path '..'" do
+      bad_path = ".."
+      expect { Path.new_path(bad_path) }.to raise_error(Hocon::ConfigError::ConfigBadPathError)
+    end
+  end
+end

data/spec/unit/typesafe/config/public_api_spec.rb

@@ -0,0 +1,520 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'test_utils'
+require 'hocon'
+require 'hocon/config_factory'
+require 'hocon/config_value_factory'
+require 'hocon/impl/config_delayed_merge_object'
+require 'hocon/impl/replaceable_merge_stack'
+require 'hocon/config_util'
+
+# Note: Skipping many tests that rely on java's System.getProperties functionality,
+#   which lets you access things like "os.name", "java.vendor", and "user.home"
+# Also skipping
+
+ConfigFactory = Hocon::ConfigFactory
+ConfigValueFactory = Hocon::ConfigValueFactory
+SimpleConfigObject = Hocon::Impl::SimpleConfigObject
+SimpleConfigList = Hocon::Impl::SimpleConfigList
+ConfigUtil = Hocon::ConfigUtil
+
+shared_examples_for "test_from_value" do
+  default_value_description = "hardcoded value"
+
+  specify "create_from made into a config value should equal the expected value" do
+    expect(Hocon::ConfigValueFactory.from_any_ref(create_from)).to eq(expected_value)
+  end
+
+  specify "create_from made into a config value with origin description should equal the expected value" do
+    expect(Hocon::ConfigValueFactory.from_any_ref(create_from, "foo")).to eq(expected_value)
+  end
+
+  specify "descriptions match" do
+    if create_from.is_a?(Hocon::ConfigValue)
+      # description is ignored for createFrom that is already a ConfigValue
+      expect(Hocon::ConfigValueFactory.from_any_ref(create_from).origin.description).to eq(create_from.origin.description)
+    else
+      expect(Hocon::ConfigValueFactory.from_any_ref(create_from).origin.description).to eq(default_value_description)
+      expect(Hocon::ConfigValueFactory.from_any_ref(create_from, "foo").origin.description).to eq("foo")
+    end
+  end
+end
+
+describe "basic load and get" do
+  conf = ConfigFactory.load_file(TestUtils.resource_file("test01"))
+
+  specify "should be able to see some values in the config object" do
+    expect(conf.get_int("ints.fortyTwo")).to eq(42)
+    child = conf.get_config("ints")
+
+    expect(child.get_int("fortyTwo")).to eq(42)
+  end
+end
+
+describe "loading JSON only" do
+  options = Hocon::ConfigParseOptions.defaults.set_syntax(Hocon::ConfigSyntax::JSON)
+  conf = ConfigFactory.load_file_with_parse_options(TestUtils.resource_file("test01"), options)
+
+  specify "should be missing value specific to CONF files" do
+    TestUtils.intercept(Hocon::ConfigError::ConfigMissingError) do
+      conf.get_int("ints.fortyTwo")
+    end
+  end
+
+  specify "should find value specific to the JSON file" do
+    expect(conf.get_int("fromJson1")).to eq(1)
+  end
+end
+
+describe "loading CONF only" do
+  options = Hocon::ConfigParseOptions.defaults.set_syntax(Hocon::ConfigSyntax::CONF)
+  conf = ConfigFactory.load_file_with_parse_options(TestUtils.resource_file("test01"), options)
+
+  specify "should be missing value specific to JSON files" do
+    TestUtils.intercept(Hocon::ConfigError::ConfigMissingError) do
+      conf.get_int("fromJson1")
+    end
+
+    TestUtils.intercept(Hocon::ConfigError::ConfigMissingError) do
+      conf.get_int("fromProps.one")
+    end
+  end
+
+  specify "should find value specific to the CONF file" do
+    expect(conf.get_int("ints.fortyTwo")).to eq(42)
+  end
+end
+
+describe "ConfigFactory#load_file_with_resolve_options" do
+  options = Hocon::ConfigResolveOptions.defaults
+  conf = ConfigFactory.load_file_with_resolve_options(TestUtils.resource_file("test01"), options)
+
+  specify "sanity check to make sure load_file_with_resolve_options act strange" do
+    expect(conf.get_int("ints.fortyTwo")).to eq(42)
+  end
+end
+
+describe "empty configs" do
+  empty = ConfigFactory.empty
+  empty_foo = ConfigFactory.empty("foo")
+
+  specify "empty config is empty" do
+    expect(empty.empty?).to be true
+  end
+
+  specify "empty config's origin should be 'empty config'" do
+    expect(empty.origin.description).to eq("empty config")
+  end
+
+  specify "empty config with origin description is empty" do
+    expect(empty_foo.empty?).to be true
+  end
+
+  specify "empty config with origin description 'foo' is having it's description set" do
+    expect(empty_foo.origin.description).to eq("foo")
+  end
+end
+
+describe "Creating objects with ConfigValueFactory" do
+  context "from true" do
+    let(:expected_value) { TestUtils.bool_value(true) }
+    let(:create_from) { true }
+
+    include_examples "test_from_value"
+  end
+
+  context "from false" do
+    let(:expected_value) { TestUtils.bool_value(false) }
+    let(:create_from) { false }
+
+    include_examples "test_from_value"
+  end
+
+  context "from nil" do
+    let(:expected_value) { TestUtils.null_value }
+    let(:create_from) { nil }
+
+    include_examples "test_from_value"
+  end
+
+  context "from int" do
+    let(:expected_value) { TestUtils.int_value(5) }
+    let(:create_from) { 5 }
+
+    include_examples "test_from_value"
+  end
+
+  context "from float" do
+    let(:expected_value) { TestUtils.double_value(3.14) }
+    let(:create_from) { 3.14 }
+
+    include_examples "test_from_value"
+  end
+
+  context "from string" do
+    let(:expected_value) { TestUtils.string_value("hello world") }
+    let(:create_from) { "hello world" }
+
+    include_examples "test_from_value"
+  end
+
+  context "from empty hash" do
+    let(:expected_value) { SimpleConfigObject.new(TestUtils.fake_origin, {}) }
+    let(:create_from) { {} }
+
+    include_examples "test_from_value"
+  end
+
+  context "from populated hash" do
+    value_hash = TestUtils.config_map({"a" => 1, "b" => 2, "c" => 3})
+
+    let(:expected_value) { SimpleConfigObject.new(TestUtils.fake_origin, value_hash) }
+    let(:create_from) { {"a" => 1, "b" => 2, "c" => 3} }
+
+    include_examples "test_from_value"
+
+    specify "from_map should also work" do
+      # from_map is just a wrapper around from_any_ref
+      expect(ConfigValueFactory.from_map({"a" => 1, "b" => 2, "c" => 3}).origin.description).to eq("hardcoded value")
+      expect(ConfigValueFactory.from_map({"a" => 1, "b" => 2, "c" => 3}, "foo").origin.description).to eq("foo")
+    end
+  end
+
+  context "from empty array" do
+    let(:expected_value) { SimpleConfigList.new(TestUtils.fake_origin, []) }
+    let(:create_from) { [] }
+
+    include_examples "test_from_value"
+  end
+
+  context "from populated array" do
+    value_array = [1, 2, 3].map { |v| TestUtils.int_value(v) }
+
+    let(:expected_value) { SimpleConfigList.new(TestUtils.fake_origin, value_array) }
+    let(:create_from) { [1, 2, 3] }
+
+    include_examples "test_from_value"
+  end
+
+  # Omitting tests that involve trees and iterators
+  # Omitting tests using units (memory size, duration, etc)
+
+  context "from existing Config values" do
+    context "from int" do
+      let(:expected_value) { TestUtils.int_value(1000) }
+      let(:create_from) { TestUtils.int_value(1000) }
+
+      include_examples "test_from_value"
+    end
+
+    context "from string" do
+      let(:expected_value) { TestUtils.string_value("foo") }
+      let(:create_from) { TestUtils.string_value("foo") }
+
+      include_examples "test_from_value"
+    end
+
+    context "from hash" do
+      int_map = {"a" => 1, "b" => 2, "c" => 3}
+      let(:expected_value) { SimpleConfigObject.new(TestUtils.fake_origin, TestUtils.config_map(int_map)) }
+      let(:create_from) { SimpleConfigObject.new(TestUtils.fake_origin, TestUtils.config_map(int_map)) }
+
+      include_examples "test_from_value"
+    end
+  end
+
+  context "from existing list of Config values" do
+    int_list = [1, 2, 3].map { |v| TestUtils.int_value(v) }
+
+    let(:expected_value) { SimpleConfigList.new(TestUtils.fake_origin, int_list) }
+    let(:create_from) { int_list }
+
+    include_examples "test_from_value"
+  end
+end
+
+describe "round tripping unwrap" do
+  conf = ConfigFactory.load_file(TestUtils.resource_file("test01"))
+
+  unwrapped = conf.root.unwrapped
+
+  rewrapped = ConfigValueFactory.from_map(unwrapped, conf.origin.description)
+  reunwrapped = rewrapped.unwrapped
+
+  specify "conf has a lot of stuff in it" do
+    expect(conf.root.size).to be > 4
+  end
+
+  specify "rewrapped conf equals conf" do
+    expect(rewrapped).to eq(conf.root)
+  end
+
+  specify "reunwrapped conf equals unwrapped conf" do
+    expect(unwrapped).to eq(reunwrapped)
+  end
+end
+
+# Omitting Tests (and functionality) for ConfigFactory.parse_map until I know if it's
+# a priority
+
+describe "default parse options" do
+  def check_not_found(e)
+    ["No such", "not found", "were found"].any? { |string| e.message.include?(string)}
+  end
+
+  let(:defaults) { Hocon::ConfigParseOptions::defaults }
+
+  specify "allow missing == true" do
+    expect(defaults.allow_missing?).to be true
+  end
+
+  specify "includer == nil" do
+    expect(defaults.includer).to be_nil
+  end
+
+  specify "origin description == nil" do
+    expect(defaults.origin_description).to be_nil
+  end
+
+  specify "syntax == nil" do
+    expect(defaults.syntax).to be_nil
+  end
+
+  context "allow missing with ConfigFactory#parse_file" do
+    specify "nonexistant conf throws error when allow_missing? == false" do
+      allow_missing_false = Hocon::ConfigParseOptions::defaults.set_allow_missing(false)
+
+      e = TestUtils.intercept(Hocon::ConfigError::ConfigIOError) do
+        ConfigFactory.parse_file(TestUtils.resource_file("nonexistant.conf"), allow_missing_false)
+      end
+
+      expect(check_not_found(e)).to be true
+    end
+
+    specify "nonexistant conf returns empty conf when allow_missing? == false" do
+      allow_missing_true = Hocon::ConfigParseOptions::defaults.set_allow_missing(true)
+
+      conf = ConfigFactory.parse_file(TestUtils.resource_file("nonexistant.conf"), allow_missing_true)
+
+      expect(conf.empty?).to be true
+    end
+  end
+
+  context "allow missing with ConfigFactory#parse_file_any_syntax" do
+    specify "nonexistant conf throws error when allow_missing? == false" do
+      allow_missing_false = Hocon::ConfigParseOptions::defaults.set_allow_missing(false)
+
+      e = TestUtils.intercept(Hocon::ConfigError::ConfigIOError) do
+        ConfigFactory.parse_file_any_syntax(TestUtils.resource_file("nonexistant"), allow_missing_false)
+      end
+
+      expect(check_not_found(e)).to be true
+    end
+
+    specify "nonexistant conf returns empty conf when allow_missing? == false" do
+      allow_missing_true = Hocon::ConfigParseOptions::defaults.set_allow_missing(true)
+
+      conf = ConfigFactory.parse_file_any_syntax(TestUtils.resource_file("nonexistant"), allow_missing_true)
+
+      expect(conf.empty?).to be true
+    end
+  end
+
+  # Omitting ConfigFactory.prase_resources_any_syntax since we're not supporting it
+  context "allow missing shouldn't mess up includes" do
+    # test03.conf contains some nonexistent includes. check that
+    # setAllowMissing on the file (which is not missing) doesn't
+    # change that the includes are allowed to be missing.
+    # This can break because some options might "propagate" through
+    # to includes, but we don't want them all to do so.
+
+    allow_missing_true = Hocon::ConfigParseOptions::defaults.set_allow_missing(true)
+    allow_missing_false = Hocon::ConfigParseOptions::defaults.set_allow_missing(false)
+
+    conf = ConfigFactory.parse_file(TestUtils.resource_file("test03.conf"), allow_missing_false)
+    conf2 = ConfigFactory.parse_file(TestUtils.resource_file("test03.conf"), allow_missing_true)
+
+    specify "conf should have stuff from test01.conf" do
+      expect(conf.get_int("test01.booleans")).to eq(42)
+    end
+
+    specify "both confs should be equal regardless of allow_missing being true or false" do
+      expect(conf).to eq(conf2)
+    end
+  end
+end
+
+# Omitting test that creates a subclass of ConfigIncluder to record everything that's
+# included by a .conf file. It's complex and we've decided the functionality is well
+# tested elsewhere and right now it isn't worth the effort.
+
+describe "string parsing" do
+  specify "should parse correctly" do
+    conf = ConfigFactory.parse_string("{ a : b }", Hocon::ConfigParseOptions.defaults)
+
+    expect(conf.get_string("a")).to eq("b")
+  end
+end
+
+
+# Omitting tests for parse_file_any_syntax in the interests of time since this has already
+# been tested above
+
+# Omitting classpath tests
+
+describe "config_utils" do
+  # This is to test the public wrappers around ConfigImplUtils
+
+  specify "can join and split paths" do
+    expect(ConfigUtil.join_path("", "a", "b", "$")).to eq("\"\".a.b.\"$\"")
+    expect(ConfigUtil.join_path_from_list(["", "a", "b", "$"])).to eq("\"\".a.b.\"$\"")
+    expect(ConfigUtil.split_path("\"\".a.b.\"$\"")).to eq(["", "a", "b", "$"])
+  end
+
+  specify "should throw errors on invalid paths" do
+    TestUtils.intercept(Hocon::ConfigError) do
+      ConfigUtil.split_path("$")
+    end
+
+    TestUtils.intercept(Hocon::ConfigError) do
+      # no args
+      ConfigUtil.join_path
+    end
+
+    TestUtils.intercept(Hocon::ConfigError) do
+      # empty list
+      ConfigUtil.join_path_from_list([])
+    end
+  end
+
+  specify "should quote strings correctly" do
+    expect(ConfigUtil.quote_string("")).to eq("\"\"")
+    expect(ConfigUtil.quote_string("a")).to eq("\"a\"")
+    expect(ConfigUtil.quote_string("\n")).to eq("\"\\n\"")
+  end
+end
+
+# Omitting tests that use class loaders
+
+describe "detecting cycles" do
+  specify "should detect a cycle" do
+    e = TestUtils.intercept(Hocon::ConfigError::ConfigParseError) do
+      ConfigFactory.load_file(TestUtils.resource_file("cycle.conf"))
+    end
+
+    # Message mentioning cycle
+    expect(e.message).to include("include statements nested")
+  end
+end
+
+describe "including from list" do
+  # We would ideally make this case NOT throw an exception but we need to do some work
+  # to get there, see https://github.com/typesafehub/config/issues/160
+  specify "should throw error when trying to include from list" do
+    e = TestUtils.intercept(Hocon::ConfigError::ConfigParseError) do
+      ConfigFactory.load_file(TestUtils.resource_file("include-from-list.conf"))
+    end
+
+    # Message mentioning current implementation limitations
+    expect(e.message).to include("limitation")
+  end
+end
+
+# Omitting tests using System.getProperty since it's java specific
+
+# Omitting serialization tests since we aren't supporting it
+
+describe "using some values without resolving" do
+  conf = ConfigFactory.parse_string("a=42,b=${NOPE}")
+
+  specify "should be able to use some values without resolving" do
+    expect(conf.get_int("a")).to eq(42)
+  end
+
+  specify "unresolved value should throw error" do
+    TestUtils.intercept(Hocon::ConfigError::ConfigNotResolvedError) do
+      conf.get_int("b")
+    end
+  end
+end
+
+describe "include file statements" do
+  conf = ConfigFactory.parse_file(TestUtils.resource_file("file-include.conf"))
+
+  specify "should find values from each included file" do
+    expect(conf.get_int("base")).to eq(41)
+    expect(conf.get_int("foo")).to eq(42)
+    expect(conf.get_int("bar")).to eq(43)
+    # these two do not work right now, because we do not
+    # treat the filename as relative to the including file
+    # if file() is specified, so `include file("bar-file.conf")`
+    # fails.
+    #assertEquals("got bar-file.conf", 44, conf.getInt("bar-file"))
+    #assertEquals("got subdir/baz.conf", 45, conf.getInt("baz"))
+  end
+
+  specify "should not find certain paths" do
+    expect(conf.has_path?("bar-file")).to be false
+    expect(conf.has_path?("baz")).to be false
+  end
+end
+
+describe "Config#has_path_or_null" do
+  conf = ConfigFactory.parse_string("x.a=null,x.b=42")
+
+  specify "has_path_or_null returns correctly" do
+    # hasPath says false for null
+    expect(conf.has_path?("x.a")).to be false
+    # hasPathOrNull says true for null
+    expect(conf.has_path_or_null?("x.a")).to be true
+
+    # hasPath says true for non-null
+    expect(conf.has_path?("x.b")).to be true
+    # hasPathOrNull says true for non-null
+    expect(conf.has_path_or_null?("x.b")).to be true
+
+    # hasPath says false for missing
+    expect(conf.has_path?("x.c")).to be false
+    # hasPathOrNull says false for missing
+    expect(conf.has_path_or_null?("x.c")).to be false
+
+    # hasPath says false for missing under null
+    expect(conf.has_path?("x.a.y")).to be false
+    # hasPathOrNull says false for missing under null
+    expect(conf.has_path_or_null?("x.a.y")).to be false
+
+    # hasPath says false for missing under missing
+    expect(conf.has_path?("x.c.y")).to be false
+    # hasPathOrNull says false for missing under missing
+    expect(conf.has_path_or_null?("x.c.y")).to be false
+
+  end
+end
+
+describe "Config#get_is_null" do
+  conf = ConfigFactory.parse_string("x.a=null,x.b=42")
+
+  specify "should return whether or not values are null correctly" do
+    expect(conf.is_null?("x.a")).to be true
+    expect(conf.is_null?("x.b")).to be false
+  end
+
+  specify "should throw error for missing values" do
+    TestUtils.intercept(Hocon::ConfigError::ConfigMissingError) do
+      conf.is_null?("x.c")
+    end
+  end
+
+  specify "should throw error for missing underneal null" do
+    TestUtils.intercept(Hocon::ConfigError::ConfigMissingError) do
+      conf.is_null?("x.a.y")
+    end
+  end
+
+  specify "should throw error for missing underneath missing" do
+    TestUtils.intercept(Hocon::ConfigError::ConfigMissingError) do
+      conf.is_null?("x.c.y")
+    end
+  end
+end