Fremdschlüssel finden

Die Schlüssel für das beschriebene Model lassen sich in zumindest mit Postgres folgendermaßen auflisten:

def foreign_keys(to_table)
  ActiveRecord::Base.connection.tables.map do |table_name|
    ActiveRecord::Base.connection.foreign_keys(table_name).select{ |index| index.to_table == to_table }
  end.flatten
end

Konfigurierte Assoziationen finden

Die Assoziationen eines Models finden wir mit folgendem Ansatz. Wir ignorieren Assoziationen mit Scopes, da hier nicht ohne weiteres festgestellt werden kann, ob diese alle möglichen Verbindungen abdecken. Auch beschränken wir uns auf Has-many- und Has-one-Beziehungen, da diese zumindest aktuell die einzig relevanten sind. Sollte hier etwas fehlen ist dies auch nicht weiter tragisch, da der Test im Zweifel lieber zu viel als zu wenig bemängeln soll.

def safe_associations(target_class)
  associations =
    target_class.reflect_on_all_associations(:has_many) +
    target_class.reflect_on_all_associations(:has_one)
  associations.select{ |assoc| assoc.options[:dependent].in?(%i{destroy nullify}) && assoc.scope.nil? }
end

Shared Example für verdächtige Keys

Nun können die gültigen Konfigurationen von den Fremdschlüsseln abziehen. Nur wenn die Differenz leer ist, sind alle Schlüssel konfiguriert. Da wir bei Scopes etwas übervorsichtig sind, erlauben wir aber auch eine ignore-Option, um bestimmte Fremdschlüssel zu ignorieren:

shared_examples 'a dependent model' do  |options = {}|
  it 'has a dependent option for has_* associations' do
    foreign_keys = foreign_keys(described_class.table_name)
    associations = safe_associations(described_class)
    ignore = options[:ignore] || []

    suspicious_keys = 
      foreign_keys.map{ |key| "#{key.from_table}.#{key.column}" } -
      associations.map{ |assoc| "#{assoc.klass.table_name}.#{assoc.foreign_key}" } -
      ignore

    expect(suspicious_keys).to be_empty
  end

  # ...
end

Nun noch die Fehlermeldungen modifizieren und etwas Doku ergänzen und schon kann das Example in Model-Specs eingebunden werden:

describe BookWithChapters do
  it_behaves_like 'a dependent model'
end

Unter Ubuntu 14.10 installieren wir Postgre und betrachten das automatisch angelegte Standard-Cluster:

sudo apt-get install postgresql

pg_lsclusters
Ver Cluster Port Status Owner Data directory Log file
9.3 main 5432 online postgres /var/lib/postgresql/9.3/main /var/log/postgresql/postgresql-9.3-main.log

Es gehört dem Nutzer postgres und ist unter /var/lib beheimatet. Beides ist auf meiner Entwicklungsmachine nicht erste Wahl. Ich droppe daher den Cluster und erstelle einen neuen, den ich meinem eigenen Nutzer zuordne:

sudo pg_dropcluster --stop 9.3 main
sudo pg_createcluster --user sg -d /home/sg/.postgresqldata 9.3 main

pg_lsclusters
Ver Cluster Port Status Owner Data directory Log file
9.3 main 5432 online sg /home/sg/.postgresqldata /var/log/postgresql/postgresql-9.3-main.log

Abschließend muss die Datenbank ggf. noch gestartet werden und man kann mit dem Standardnutzer ganz normal arbeiten:

sudo service postgresql start
createuser -dPER my-project-db-user

PG::InsufficientPrivilege: ERROR:  permission denied to create database
[...]

Es mag eine falsche Einstellung sein (ein einfaches rspec verursacht das Problem nicht), aber offensichtlich benötigt der Datenbanknutzer in meiner Konfiguration das Recht, neue Datenbanken zu erstellen. Auf meiner lokalen Maschine, wo die Tests laufen, kann ich das verantworten.

Postgres-Kommandozeile aufrufen:

sudo su - postgres
psql

Recht zum Erstellen der Datenbank an Nutzer vergeben:

ALTER USER "my-db-user" CREATEDB;

Transaktionen in PostgreSQL

begin;
alter table mytable rename column id to name;
\d mytable

         Table "public.mytable"
   Column   |   Type     |   Modifiers   
------------+------------+--------------
 name       | bigint     | not null

rollback;
\d

         Table "public.mytable"
   Column   |   Type     |   Modifiers   
------------+------------+--------------
 id         | bigint     | not null

Sind die vorgenommenen Änderungen korrekt, können sie mit commit; übernommen werden. Der offizielle SQL-Befehl zum Starten einer Transaktion ist start transaction;. Allerdings unterstützen alle mir bekannten Datenbanken die etwas handlichere Form begin;.

Verschachtelte Transaktionen: Savepoints

Ist der Test komplexer, so dass man Transaktionen schachteln möchte, kann man sogenannte Savepoints verwenden.

begin;
-- Änderung 1
savepoint sp1;
-- Änderung 2a
rollback to savepoint sp1; -- 2a zurücknehmen
-- Änderung 2b
rollback; -- 2b und 1 zurücknehmen

Transaktionen in MySQL

Die PostgreSQL-Beispiele werden auch von MySQL unterstützt.

$result = pg_query("SELECT $rowName FROM $tableName;");
while ($row = pg_fetch_assoc($result)) {
    $fileHandler = fopen($filePath, 'wb');
    fwrite($fileHandler, pg_unescape_bytea($row[$rowName]));
    fclose($fileHandler);
}