Initial custom domain model and tests

simonbaird · simonbaird · commit 3dc8657fa740 · 2026-04-21T17:46:41.000-04:00
diff --git a/rails/app/models/custom_domain.rb b/rails/app/models/custom_domain.rb
@@ -0,0 +1,66 @@
+class CustomDomain < ApplicationRecord
+  belongs_to :site
+
+  validates :site_id, uniqueness: true
+  validates :domain, presence: true, uniqueness: true, format: { with: /\A[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+\z/ }
+  validate :not_reserved_domain
+
+  enum :status, { pending_verification: 0, verified: 1, active: 2, failed: 3 }, default: :pending_verification
+  enum :ssl_status, { pending: 0, issued: 1, expired: 2, failed: 3 }, prefix: :ssl, default: :pending
+
+  scope :expiring_soon, -> { where(ssl_status: :issued).where('ssl_expires_at < ?', 30.days.from_now) }
+  scope :fully_active, -> { where(status: :active, ssl_status: :issued) }
+
+  before_validation :normalize_domain
+  before_create :generate_verification_token
+
+  # Check if domain is fully active (verified and has valid SSL)
+  def fully_active?
+    active? && ssl_issued?
+  end
+
+  # DNS TXT record name for verification
+  def verification_record_name
+    "_tiddlyhost-verification.#{domain}"
+  end
+
+  # DNS TXT record value for verification
+  def verification_record_value
+    verification_token
+  end
+
+  # Human-readable DNS verification instructions
+  def dns_verification_instructions
+    <<~INSTRUCTIONS
+      To verify ownership of your domain, add this DNS TXT record:
+
+      Name:  #{verification_record_name}
+      Type:  TXT
+      Value: #{verification_record_value}
+
+      After adding the record, click "Verify Domain" to continue.
+      DNS changes can take a few minutes to propagate.
+    INSTRUCTIONS
+  end
+
+  private
+
+  def normalize_domain
+    self.domain = domain.downcase.strip if domain.present?
+  end
+
+  def not_reserved_domain
+    return if domain.blank?
+
+    reserved_domains = ['tiddlyhost.com', 'tiddlyspot.com', 'localhost']
+    reserved_patterns = [/\.tiddlyhost\.com\z/, /\.tiddlyspot\.com\z/]
+
+    if reserved_domains.include?(domain) || reserved_patterns.any? { |pattern| domain.match?(pattern) }
+      errors.add(:domain, "cannot use reserved domains or their subdomains")
+    end
+  end
+
+  def generate_verification_token
+    self.verification_token = SecureRandom.hex(16)
+  end
+end
diff --git a/rails/app/models/site.rb b/rails/app/models/site.rb
@@ -11,6 +11,8 @@ class Site < ApplicationRecord
   # could return nil even if the id field is present.)
   belongs_to :cloned_from, optional: true, class_name: :Site
 
+  has_one :custom_domain, dependent: :destroy
+
   # The timestamps can be a few milliseconds apart, so that's why we need the interval
   # Todo: blob_created_at would be a more useful timestamp to use here than updated_at.
   scope :never_updated,         -> { where("AGE(sites.updated_at, sites.created_at) <= INTERVAL '0.5 SECOND'") }
diff --git a/rails/test/models/custom_domain_test.rb b/rails/test/models/custom_domain_test.rb
@@ -0,0 +1,273 @@
+require 'test_helper'
+
+class CustomDomainTest < ActiveSupport::TestCase
+  setup do
+    @site = sites(:mysite)
+    @custom_domain = CustomDomain.new(
+      site: @site,
+      domain: 'example.com'
+    )
+  end
+
+  test 'valid custom domain' do
+    assert @custom_domain.valid?
+  end
+
+  test 'domain is required' do
+    @custom_domain.domain = nil
+    refute @custom_domain.valid?
+    assert_includes @custom_domain.errors[:domain], "can't be blank"
+  end
+
+  test 'domain must be unique' do
+    @custom_domain.save!
+    another_site = Site.create!(name: 'another-site', user: @site.user, empty: @site.empty)
+    duplicate = CustomDomain.new(site: another_site, domain: 'example.com')
+    refute duplicate.valid?
+    assert_includes duplicate.errors[:domain], "has already been taken"
+  end
+
+  test 'domain normalization downcases domain' do
+    @custom_domain.domain = 'EXAMPLE.COM'
+    @custom_domain.valid?
+    assert_equal 'example.com', @custom_domain.domain
+  end
+
+  test 'domain normalization strips whitespace' do
+    @custom_domain.domain = '  example.com  '
+    @custom_domain.valid?
+    assert_equal 'example.com', @custom_domain.domain
+  end
+
+  test 'domain format validation' do
+    # Valid domains
+    [
+      'example.com',
+      'sub.example.com',
+      'my-site.example.com',
+      'a.b.c.example.com',
+      '123.example.com',
+    ].each do |valid_domain|
+      @custom_domain.domain = valid_domain
+      assert @custom_domain.valid?, "#{valid_domain} should be valid"
+    end
+
+    # Invalid domains
+    [
+      'example',           # no TLD
+      '-example.com',      # starts with dash
+      'example-.com',      # ends with dash
+      'exam ple.com',      # contains space
+      'example..com',      # double dot
+      '.example.com',      # starts with dot
+      'example.com.',      # ends with dot
+    ].each do |invalid_domain|
+      @custom_domain.domain = invalid_domain
+      refute @custom_domain.valid?, "#{invalid_domain} should be invalid"
+    end
+  end
+
+  test 'blocks exact reserved domains' do
+    ['tiddlyhost.com', 'tiddlyspot.com', 'localhost'].each do |reserved|
+      @custom_domain.domain = reserved
+      refute @custom_domain.valid?
+      assert_includes @custom_domain.errors[:domain], "cannot use reserved domains or their subdomains"
+    end
+  end
+
+  test 'blocks subdomains of reserved domains' do
+    [
+      'www.tiddlyhost.com',
+      'admin.tiddlyhost.com',
+      'api.tiddlyhost.com',
+      'foo.tiddlyspot.com',
+      'bar.baz.tiddlyhost.com',
+    ].each do |reserved_subdomain|
+      @custom_domain.domain = reserved_subdomain
+      refute @custom_domain.valid?, "#{reserved_subdomain} should be blocked"
+      assert_includes @custom_domain.errors[:domain], "cannot use reserved domains or their subdomains"
+    end
+  end
+
+  test 'allows domains containing reserved words but not as subdomain' do
+    # These should be allowed since they're not subdomains
+    [
+      'tiddlyhostfan.com',
+      'mytiddlyhost.org',
+    ].each do |allowed_domain|
+      @custom_domain.domain = allowed_domain
+      assert @custom_domain.valid?, "#{allowed_domain} should be allowed"
+    end
+  end
+
+  test 'generates verification token on create' do
+    assert_nil @custom_domain.verification_token
+    @custom_domain.save!
+    assert_not_nil @custom_domain.verification_token
+    assert_equal 32, @custom_domain.verification_token.length # hex(16) = 32 chars
+  end
+
+  test 'default status is pending_verification' do
+    @custom_domain.save!
+    assert @custom_domain.pending_verification?
+    assert_equal 0, @custom_domain.status_before_type_cast
+  end
+
+  test 'default ssl_status is pending' do
+    @custom_domain.save!
+    assert @custom_domain.ssl_pending?
+    assert_equal 0, @custom_domain.ssl_status_before_type_cast
+  end
+
+  test 'status enum states' do
+    @custom_domain.save!
+
+    @custom_domain.pending_verification!
+    assert @custom_domain.pending_verification?
+
+    @custom_domain.verified!
+    assert @custom_domain.verified?
+
+    @custom_domain.active!
+    assert @custom_domain.active?
+
+    @custom_domain.failed!
+    assert @custom_domain.failed?
+  end
+
+  test 'ssl_status enum states with prefix' do
+    @custom_domain.save!
+
+    @custom_domain.ssl_pending!
+    assert @custom_domain.ssl_pending?
+
+    @custom_domain.ssl_issued!
+    assert @custom_domain.ssl_issued?
+
+    @custom_domain.ssl_expired!
+    assert @custom_domain.ssl_expired?
+
+    @custom_domain.ssl_failed!
+    assert @custom_domain.ssl_failed?
+  end
+
+  test 'fully_active? requires both active status and issued SSL' do
+    @custom_domain.save!
+
+    # Not active yet
+    @custom_domain.pending_verification!
+    @custom_domain.ssl_pending!
+    refute @custom_domain.fully_active?
+
+    # Active but no SSL
+    @custom_domain.active!
+    @custom_domain.ssl_pending!
+    refute @custom_domain.fully_active?
+
+    # SSL issued but not active
+    @custom_domain.verified!
+    @custom_domain.ssl_issued!
+    refute @custom_domain.fully_active?
+
+    # Both active and SSL issued
+    @custom_domain.active!
+    @custom_domain.ssl_issued!
+    assert @custom_domain.fully_active?
+  end
+
+  test 'fully_active scope' do
+    @custom_domain.save!
+
+    # Create additional sites for testing (one site = one custom domain)
+    pending_site = Site.create!(name: 'pending-site', user: @site.user, empty: @site.empty)
+    active_site = Site.create!(name: 'active-site', user: @site.user, empty: @site.empty)
+
+    pending_domain = CustomDomain.create!(site: pending_site, domain: 'pending.com')
+    active_domain = CustomDomain.create!(
+      site: active_site,
+      domain: 'active.com',
+      status: :active,
+      ssl_status: :issued
+    )
+
+    fully_active_domains = CustomDomain.fully_active
+    assert_includes fully_active_domains, active_domain
+    refute_includes fully_active_domains, pending_domain
+    refute_includes fully_active_domains, @custom_domain
+  end
+
+  test 'expiring_soon scope only includes issued certificates' do
+    @custom_domain.save!
+
+    # Create additional sites for testing (one site = one custom domain)
+    expiring_site = Site.create!(name: 'expiring-site', user: @site.user, empty: @site.empty)
+    safe_site = Site.create!(name: 'safe-site', user: @site.user, empty: @site.empty)
+    pending_site = Site.create!(name: 'pending-cert-site', user: @site.user, empty: @site.empty)
+
+    # Create domains with different SSL states
+    expired_soon = CustomDomain.create!(
+      site: expiring_site,
+      domain: 'expires-soon.com',
+      ssl_status: :issued,
+      ssl_expires_at: 15.days.from_now
+    )
+
+    not_expiring = CustomDomain.create!(
+      site: safe_site,
+      domain: 'not-expiring.com',
+      ssl_status: :issued,
+      ssl_expires_at: 60.days.from_now
+    )
+
+    pending_cert = CustomDomain.create!(
+      site: pending_site,
+      domain: 'pending-cert.com',
+      ssl_status: :pending,
+      ssl_expires_at: 15.days.from_now
+    )
+
+    expiring = CustomDomain.expiring_soon
+    assert_includes expiring, expired_soon
+    refute_includes expiring, not_expiring
+    refute_includes expiring, pending_cert
+  end
+
+  test 'verification_record_name' do
+    @custom_domain.domain = 'example.com'
+    assert_equal '_tiddlyhost-verification.example.com', @custom_domain.verification_record_name
+  end
+
+  test 'verification_record_value returns token' do
+    @custom_domain.save!
+    assert_equal @custom_domain.verification_token, @custom_domain.verification_record_value
+  end
+
+  test 'dns_verification_instructions contains key information' do
+    @custom_domain.save!
+    instructions = @custom_domain.dns_verification_instructions
+
+    assert_includes instructions, @custom_domain.verification_record_name
+    assert_includes instructions, @custom_domain.verification_token
+    assert_includes instructions, 'TXT'
+    assert_includes instructions, 'Verify Domain'
+  end
+
+  test 'belongs to site' do
+    assert_equal @site, @custom_domain.site
+  end
+
+  test 'site can only have one custom domain' do
+    @custom_domain.save!
+
+    second_domain = CustomDomain.new(site: @site, domain: 'another.com')
+    refute second_domain.valid?
+    assert_includes second_domain.errors[:site_id], "has already been taken"
+  end
+
+  test 'custom domain is destroyed when site is destroyed' do
+    @custom_domain.save!
+    assert_difference 'CustomDomain.count', -1 do
+      @site.destroy
+    end
+  end
+end
