trema 0.1.3

data/unittests/lib/daemon_test.c

@@ -0,0 +1,664 @@
+/*
+ * Unit tests for daemon functions.
+ * 
+ * Author: Yasuhito Takamiya <yasuhito@gmail.com>
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "bool.h"
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "daemon.h"
+
+
+/********************************************************************************
+ * Mocks.
+ ********************************************************************************/
+
+void
+mock_die( char *format, ... ) {
+  va_list args;
+  va_start( args, format );
+  char message[ 1000 ];
+  vsprintf( message, format, args );
+  va_end( args );
+
+  check_expected( message );
+  mock_assert( false, "UNREACHABLE", __FILE__, __LINE__ ); } // This hoaxes gcov.
+
+
+int
+mock_chdir( char *path ) {
+  UNUSED( path );
+  return ( int ) mock();
+}
+
+
+void
+mock_exit( int status ) {
+  check_expected( status );
+}
+
+
+pid_t
+mock_fork() {
+  return ( pid_t ) mock();
+}
+
+
+pid_t
+mock_setsid() {
+  return ( pid_t ) mock();
+}
+
+
+mode_t
+mock_umask( mode_t mode ) {
+  check_expected( mode );
+  return mode;
+}
+
+
+int
+mock_close( int fd ) {
+  check_expected( fd );
+  return 0;
+}
+
+
+int
+mock_open( char *pathname, int flags, mode_t mode ) {
+  check_expected( pathname );
+  check_expected( flags );
+  check_expected( mode );
+  return ( int ) mock();
+}
+
+
+int
+mock_lockf( int fd, int cmd, off_t len ) {
+  check_expected( fd );
+  check_expected( cmd );
+  check_expected( len );
+  return ( int ) mock();
+}
+
+
+pid_t
+mock_getpid() {
+  return 1234;
+}
+
+
+ssize_t
+mock_write( int fd, void *buf, size_t count ) {
+  check_expected( fd );
+  check_expected( buf );
+  check_expected( count );
+  return ( ssize_t ) count;
+}
+
+
+int
+mock_unlink( char *pathname ) {
+  check_expected( pathname );
+  return ( int ) mock();
+}
+
+
+int
+mock_access( char *pathname, int mode) {
+  check_expected( pathname );
+  check_expected( mode );
+  return ( int ) mock();
+}
+
+
+static size_t read_length = 0;
+static char *read_buffer = NULL;
+
+ssize_t
+mock_read( int fd, void *buf, size_t count ) {
+  check_expected( fd );
+  check_expected( buf );
+  check_expected( count );
+  if ( read_length > 0 ) {
+    memcpy( buf, read_buffer, read_length );
+  }
+  return ( int ) mock();
+}
+
+
+int
+mock_kill( pid_t pid, int sig ) {
+  check_expected( pid );
+  check_expected( sig );
+  return ( int ) mock();
+}
+
+
+int
+mock_rename( char *oldpath, char *newpath ) {
+  check_expected( oldpath );
+  check_expected( newpath );
+  return ( int ) mock();
+}
+
+
+void
+mock_warn( const char *format, ... ) {
+  UNUSED( format );
+}
+
+
+/********************************************************************************
+ * Test functions.
+ ********************************************************************************/
+
+static void
+test_daemonize_succeed() {
+  will_return( mock_chdir, 0 );
+  will_return( mock_fork, 1234 );
+  will_return( mock_setsid, 4321 );
+
+  expect_value( mock_exit, status, EXIT_SUCCESS );
+  expect_value( mock_umask, mode, 0 );
+  expect_value( mock_close, fd, STDIN_FILENO );
+  expect_value( mock_close, fd, STDOUT_FILENO );
+  expect_value( mock_close, fd, STDERR_FILENO );
+
+  daemonize( "/" );
+}
+
+
+static void
+test_daemonize_fail_if_chdir_fail() {
+  will_return( mock_chdir, -1 );
+
+  errno = EACCES;
+  expect_string( mock_die, message, "Could not cd to /: Permission denied." );
+  
+  expect_assert_failure( daemonize( "/" ) );
+  errno = 0;
+}
+
+
+static void
+test_daemonize_fail_if_fork_fail() {
+  will_return( mock_chdir, 0 );
+  will_return( mock_fork, -1 );
+
+  errno = EAGAIN;
+  expect_string( mock_die, message, "fork() failed: Resource temporarily unavailable." );
+
+  expect_assert_failure( daemonize( "/" ) );
+  errno = 0;
+}
+
+
+static void
+test_daemonize_fail_if_setsid_fail() {
+  will_return( mock_chdir, 0 );
+  will_return( mock_fork, 1234 );
+  will_return( mock_setsid, -1 );
+
+  expect_value( mock_exit, status, EXIT_SUCCESS );
+
+  errno = EPERM;
+  expect_string( mock_die, message, "setsid() failed: Operation not permitted." );
+
+  expect_assert_failure( daemonize( "/" ) );
+  errno = 0;
+}
+
+
+static void
+test_write_pid_succeed() {
+  will_return( mock_open, 1111 );
+  will_return( mock_lockf, 0 );
+
+  // Test if correctly opened.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  char buffer[] = "1234\n";
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, ( O_RDWR | O_CREAT ) );
+  expect_value( mock_open, mode, 0600 );
+
+  // Test if correctly locked.
+  expect_value( mock_lockf, fd, 1111 );
+  expect_value( mock_lockf, cmd, F_TLOCK );
+  expect_value( mock_lockf, len, 0 );
+
+  // Test if correctly written.
+  expect_value( mock_write, fd, 1111 );
+  expect_string( mock_write, buf, buffer );
+  expect_value( mock_write, count, strlen( buffer ) );
+
+  write_pid( "/home/yasuhito/trema/tmp", "chess" );
+}
+
+
+static void
+test_write_pid_fail_if_open_fail() {
+  will_return( mock_open, -1 );
+
+  // Test if correctly opened.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, ( O_RDWR | O_CREAT ) );
+  expect_value( mock_open, mode, 0600 );
+
+  expect_string( mock_die, message, "Could not create a PID file: /home/yasuhito/trema/tmp/chess.pid" );
+
+  expect_assert_failure( write_pid( "/home/yasuhito/trema/tmp", "chess" ) );
+}
+
+
+static void
+test_write_pid_fail_if_lockf_fail() {
+  will_return( mock_open, 1111 );
+  will_return( mock_lockf, -1 );
+
+  // Test if correctly locked.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, ( O_RDWR | O_CREAT ) );
+  expect_value( mock_open, mode, 0600 );
+
+  // Test if correctly locked.
+  expect_value( mock_lockf, fd, 1111 );
+  expect_value( mock_lockf, cmd, F_TLOCK );
+  expect_value( mock_lockf, len, 0 );
+
+  // lockf_return_value = -1;
+  expect_string( mock_die, message, "Could not acquire a lock on a PID file: /home/yasuhito/trema/tmp/chess.pid" );
+
+  expect_assert_failure( write_pid( "/home/yasuhito/trema/tmp", "chess" ) );
+}
+
+
+static void
+test_unlink_pid_succeed() {
+  will_return( mock_unlink, 0 );
+
+  // Test if correctly unlinked.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_unlink, pathname, path );
+
+  unlink_pid( "/home/yasuhito/trema/tmp", "chess" );
+}
+
+
+static void
+test_unlink_pid_fail_if_unlink_fail() {
+  will_return( mock_unlink, -1 );
+
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_unlink, pathname, path );
+
+  expect_string( mock_die, message, "Could not remove a PID file: /home/yasuhito/trema/tmp/chess.pid" );
+
+  expect_assert_failure( unlink_pid( "/home/yasuhito/trema/tmp", "chess" ) );
+}
+
+
+static void
+test_read_pid_successed() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  int pid_file_fd = 111;
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, pid_file_fd );
+
+  // Test if correctly read.
+  expect_value( mock_read, fd, pid_file_fd );
+  expect_not_value( mock_read, buf, NULL );
+  expect_value( mock_read, count, 10 - 1 );
+  char valid_pid_string[] = "123\n";
+  pid_t valid_pid = 123;
+  read_buffer = valid_pid_string;
+  read_length = strlen( valid_pid_string );
+  will_return( mock_read, read_length );
+
+  // Test if correctly read.
+  expect_value( mock_kill, pid, valid_pid );
+  expect_value( mock_kill, sig, 0 );
+  will_return( mock_kill, 0 );
+
+  // Test if correctly close.
+  expect_value( mock_close, fd, pid_file_fd );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == valid_pid );
+}
+
+
+static void
+test_read_pid_fail_if_access_fail() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, -1 );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_read_pid_fail_if_open_fail() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, -1 );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_read_pid_fail_if_read_fail() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  int pid_file_fd = 111;
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, pid_file_fd );
+
+  // Test if correctly read.
+  expect_value( mock_read, fd, pid_file_fd );
+  expect_not_value( mock_read, buf, NULL );
+  expect_value( mock_read, count, 10 - 1 );
+  read_length = 0;
+  will_return( mock_read, -1 );
+
+  // Test if correctly close.
+  expect_value( mock_close, fd, pid_file_fd );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_read_pid_fail_if_pid_is_invalid() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  int pid_file_fd = 111;
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, pid_file_fd );
+
+  // Test if correctly read.
+  expect_value( mock_read, fd, pid_file_fd );
+  expect_not_value( mock_read, buf, NULL );
+  expect_value( mock_read, count, 10 - 1 );
+  char INVALID_pid_string[] = "not number\n";
+  read_buffer = INVALID_pid_string;
+  read_length = strlen( INVALID_pid_string );
+  will_return( mock_read, read_length );
+
+  // Test if correctly close.
+  expect_value( mock_close, fd, pid_file_fd );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_read_pid_fail_if_pid_is_zero() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  int pid_file_fd = 111;
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, pid_file_fd );
+
+  // Test if correctly read.
+  expect_value( mock_read, fd, pid_file_fd );
+  expect_not_value( mock_read, buf, NULL );
+  expect_value( mock_read, count, 10 - 1 );
+  char ZERO_pid_string[] = "0\n";
+  read_buffer = ZERO_pid_string;
+  read_length = strlen( ZERO_pid_string );
+  will_return( mock_read, read_length );
+
+  // Test if correctly close.
+  expect_value( mock_close, fd, pid_file_fd );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_read_pid_fail_if_kill_fail_with_ESRCH() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  int pid_file_fd = 111;
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, pid_file_fd );
+
+  // Test if correctly read.
+  expect_value( mock_read, fd, pid_file_fd );
+  expect_not_value( mock_read, buf, NULL );
+  expect_value( mock_read, count, 10 - 1 );
+  char valid_pid_string[] = "123\n";
+  pid_t valid_pid = 123;
+  read_buffer = valid_pid_string;
+  read_length = strlen( valid_pid_string );
+  will_return( mock_read, read_length );
+
+  // Test if correctly read.
+  expect_value( mock_kill, pid, valid_pid );
+  expect_value( mock_kill, sig, 0 );
+  errno = ESRCH;
+  will_return( mock_kill, -1 );
+
+  // Test if correctly close.
+  expect_value( mock_close, fd, pid_file_fd );
+
+  // Test if correctly unlink.
+  expect_string( mock_unlink, pathname, path );
+  will_return( mock_unlink, 0 );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_read_pid_fail_if_kill_fail_with_EPERM() {
+  // Test if correctly access.
+  char path[] = "/home/yasuhito/trema/tmp/chess.pid";
+  expect_string( mock_access, pathname, path );
+  expect_value( mock_access, mode, R_OK );
+  will_return( mock_access, 0 );
+
+  // Test if correctly opened.
+  int pid_file_fd = 111;
+  expect_string( mock_open, pathname, path );
+  expect_value( mock_open, flags, O_RDONLY );
+  expect_value( mock_open, mode, 0 );
+  will_return( mock_open, pid_file_fd );
+
+  // Test if correctly read.
+  expect_value( mock_read, fd, pid_file_fd );
+  expect_not_value( mock_read, buf, NULL );
+  expect_value( mock_read, count, 10 - 1 );
+  char valid_pid_string[] = "123\n";
+  pid_t valid_pid = 123;
+  read_buffer = valid_pid_string;
+  read_length = strlen( valid_pid_string );
+  will_return( mock_read, read_length );
+
+  // Test if correctly read.
+  expect_value( mock_kill, pid, valid_pid );
+  expect_value( mock_kill, sig, 0 );
+  errno = EPERM;
+  will_return( mock_kill, -1 );
+
+  // Test if correctly close.
+  expect_value( mock_close, fd, pid_file_fd );
+
+  // Go
+  pid_t pid = read_pid( "/home/yasuhito/trema/tmp", "chess" );
+  assert_true( pid == -1 );
+}
+
+
+static void
+test_rename_pid_successed() {
+  // Test if correctly unlink.
+  expect_string( mock_unlink, pathname, "/home/yasuhito/trema/tmp/hello.pid" );
+  errno = ENOENT;
+  will_return( mock_unlink, -1 );
+  // Test if correctly rename.
+  expect_string( mock_rename, oldpath, "/home/yasuhito/trema/tmp/bye.pid" );
+  expect_string( mock_rename, newpath, "/home/yasuhito/trema/tmp/hello.pid" );
+  will_return( mock_rename, 0 );
+
+  // Go
+  rename_pid( "/home/yasuhito/trema/tmp", "bye", "hello" );
+}
+
+
+static void
+test_rename_pid_fail_if_rename_fail() {
+  // Test if correctly unlink.
+  expect_string( mock_unlink, pathname, "/home/yasuhito/trema/tmp/hello.pid" );
+  errno = ENOENT;
+  will_return( mock_unlink, -1 );
+  // Test if correctly rename.
+  expect_string( mock_rename, oldpath, "/home/yasuhito/trema/tmp/bye.pid" );
+  expect_string( mock_rename, newpath, "/home/yasuhito/trema/tmp/hello.pid" );
+  errno = ENOENT;
+  will_return( mock_rename, -1 );
+
+  expect_string( mock_die, message, "Could not rename a PID file from "
+                                    "/home/yasuhito/trema/tmp/bye.pid"
+                                    " to "
+                                    "/home/yasuhito/trema/tmp/hello.pid." );
+
+  // Go
+  expect_assert_failure( rename_pid( "/home/yasuhito/trema/tmp", "bye", "hello" ) );
+}
+
+
+/********************************************************************************
+ * Run tests.
+ ********************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    // daemonize() tests.
+    unit_test( test_daemonize_succeed ),
+    unit_test( test_daemonize_fail_if_chdir_fail ),
+    unit_test( test_daemonize_fail_if_fork_fail ),
+    unit_test( test_daemonize_fail_if_setsid_fail ),
+
+    // write_pid() tests.
+    unit_test( test_write_pid_succeed ),
+    unit_test( test_write_pid_fail_if_open_fail ),
+    unit_test( test_write_pid_fail_if_lockf_fail ),
+
+    // unlink_pid() tsets.
+    unit_test( test_unlink_pid_succeed ),
+    unit_test( test_unlink_pid_fail_if_unlink_fail ),
+
+    // read_pid() tests.
+    unit_test( test_read_pid_successed ),
+    unit_test( test_read_pid_fail_if_access_fail ),
+    unit_test( test_read_pid_fail_if_open_fail ),
+    unit_test( test_read_pid_fail_if_read_fail ),
+    unit_test( test_read_pid_fail_if_pid_is_invalid ),
+    unit_test( test_read_pid_fail_if_pid_is_zero ),
+    unit_test( test_read_pid_fail_if_kill_fail_with_ESRCH ),
+    unit_test( test_read_pid_fail_if_kill_fail_with_EPERM ),
+
+    // rename_pid() tests.
+    unit_test( test_rename_pid_successed ),
+    unit_test( test_rename_pid_fail_if_rename_fail ),
+
+  };
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */