libgo/go/log/syslog/syslog_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build !windows,!plan9
   6
   7 package syslog
   8
   9 import (
  10         "fmt"
  11         "io"
  12         "log"
  13         "net"
  14         "os"
  15         "testing"
  16         "time"
  17 )
  18
  19 var serverAddr string
  20
  21 func runSyslog(c net.PacketConn, done chan<- string) {
  22         var buf [4096]byte
  23         var rcvd string
  24         for {
  25                 c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
  26                 n, _, err := c.ReadFrom(buf[:])
  27                 rcvd += string(buf[:n])
  28                 if err != nil {
  29                         break
  30                 }
  31         }
  32         done <- rcvd
  33 }
  34
  35 func startServer(done chan<- string) {
  36         c, e := net.ListenPacket("udp", "127.0.0.1:0")
  37         if e != nil {
  38                 log.Fatalf("net.ListenPacket failed udp :0 %v", e)
  39         }
  40         serverAddr = c.LocalAddr().String()
  41         go runSyslog(c, done)
  42 }
  43
  44 func skipNetTest(t *testing.T) bool {
  45         if testing.Short() {
  46                 // Depends on syslog daemon running, and sometimes it's not.
  47                 t.Logf("skipping syslog test during -short")
  48                 return true
  49         }
  50         return false
  51 }
  52
  53 func TestNew(t *testing.T) {
  54         if LOG_LOCAL7 != 23<<3 {
  55                 t.Fatalf("LOG_LOCAL7 has wrong value")
  56         }
  57         if skipNetTest(t) {
  58                 return
  59         }
  60
  61         s, err := New(LOG_INFO|LOG_USER, "")
  62         if err != nil {
  63                 t.Fatalf("New() failed: %s", err)
  64         }
  65         // Don't send any messages.
  66         s.Close()
  67 }
  68
  69 func TestNewLogger(t *testing.T) {
  70         if skipNetTest(t) {
  71                 return
  72         }
  73         f, err := NewLogger(LOG_USER|LOG_INFO, 0)
  74         if f == nil {
  75                 t.Error(err)
  76         }
  77 }
  78
  79 func TestDial(t *testing.T) {
  80         if skipNetTest(t) {
  81                 return
  82         }
  83         f, err := Dial("", "", (LOG_LOCAL7|LOG_DEBUG)+1, "syslog_test")
  84         if f != nil {
  85                 t.Fatalf("Should have trapped bad priority")
  86         }
  87         f, err = Dial("", "", -1, "syslog_test")
  88         if f != nil {
  89                 t.Fatalf("Should have trapped bad priority")
  90         }
  91         l, err := Dial("", "", LOG_USER|LOG_ERR, "syslog_test")
  92         if err != nil {
  93                 t.Fatalf("Dial() failed: %s", err)
  94         }
  95         l.Close()
  96 }
  97
  98 func TestUDPDial(t *testing.T) {
  99         done := make(chan string)
 100         startServer(done)
 101         l, err := Dial("udp", serverAddr, LOG_USER|LOG_INFO, "syslog_test")
 102         if err != nil {
 103                 t.Fatalf("syslog.Dial() failed: %s", err)
 104         }
 105         msg := "udp test"
 106         l.Info(msg)
 107         expected := fmt.Sprintf("<%d>1 ", LOG_USER+LOG_INFO) + "%s %s syslog_test[%d]: udp test\n"
 108         rcvd := <-done
 109         var parsedHostname, timestamp string
 110         var pid int
 111         if hostname, err := os.Hostname(); err != nil {
 112                 t.Fatalf("Error retrieving hostname")
 113         } else {
 114                 if n, err := fmt.Sscanf(rcvd, expected, &timestamp, &parsedHostname, &pid); n != 3 ||
 115                         err != nil || hostname != parsedHostname {
 116                         t.Fatalf("s.Info() = '%q', didn't match '%q'", rcvd, expected)
 117                 }
 118         }
 119 }
 120
 121 func TestWrite(t *testing.T) {
 122         tests := []struct {
 123                 pri Priority
 124                 pre string
 125                 msg string
 126                 exp string
 127         }{
 128                 {LOG_USER | LOG_ERR, "syslog_test", "", "%s %s syslog_test[%d]: \n"},
 129                 {LOG_USER | LOG_ERR, "syslog_test", "write test", "%s %s syslog_test[%d]: write test\n"},
 130                 // Write should not add \n if there already is one
 131                 {LOG_USER | LOG_ERR, "syslog_test", "write test 2\n", "%s %s syslog_test[%d]: write test 2\n"},
 132         }
 133
 134         if hostname, err := os.Hostname(); err != nil {
 135                 t.Fatalf("Error retrieving hostname")
 136         } else {
 137                 for _, test := range tests {
 138                         done := make(chan string)
 139                         startServer(done)
 140                         l, err := Dial("udp", serverAddr, test.pri, test.pre)
 141                         if err != nil {
 142                                 t.Fatalf("syslog.Dial() failed: %s", err)
 143                         }
 144                         _, err = io.WriteString(l, test.msg)
 145                         if err != nil {
 146                                 t.Fatalf("WriteString() failed: %s", err)
 147                         }
 148                         rcvd := <-done
 149                         test.exp = fmt.Sprintf("<%d>1 ", test.pri) + test.exp
 150                         var parsedHostname, timestamp string
 151                         var pid int
 152                         if n, err := fmt.Sscanf(rcvd, test.exp, &timestamp, &parsedHostname, &pid); n != 3 ||
 153                                 err != nil || hostname != parsedHostname {
 154                                 t.Fatalf("s.Info() = '%q', didn't match '%q'", rcvd, test.exp)
 155                         }
 156                 }
 157         }
 158 }