SuiteScript
SuiteScript
SuiteScript is the NetSuite platform built on JavaScript that enables
complete customization and automation of business processes. Using the
SuiteScript APIs, core business records and user information can be accessed and
manipulated via scripts that are executed at pre-defined events. For example,
field change, form submit, before read, before write, or Web requests. They can
also be scheduled to run at specific times.
SuiteScript is comprised of several components enabling the most useful
customization in SaaS:
Suitelets & extensions to SuiteScript let you build a custom
interface that is hosted within the NetSuite framework. Suitelets allow for
completely custom HTML, Flash or NetSuite-based front-end development that can
be built from scratch or by leveraging revolutionary SuiteScript UI Objects.
Suitelets can also serve as the back-end for external HTML interfaces, providing
complete flexibility in developing application extensions to NetSuite.
SuiteScript UI Objects
& Serve as extensions which let you build a
custom interface that runs invisibly within the NetSuite framework.
Portlet SuiteScript & scripted Dashboard portlets allow for listing
of any NetSuite content on the Dashboard or inclusion of external data-feeds via
RSS, HTML or Flash, as well as Web 2.0 mashups (e.g. instant messaging, maps,
blogs, more) via embedded Inline HTML fields, or iFrames.
Scheduled SuiteScript & facilitates business process customization
via JavaScript extensions and allow for records to be processed as a scheduled
batch to automate workflows such as re-assignment of stale leads, drip-marketing
or scheduling of collection calls based on days overdue.
User Event SuiteScript & SuiteScript can be used to enforce data
validation and business rules. User Event SuiteScripts are triggered as users
work with records and data changes in NetSuite as they open, edit or save
Client SuiteScript & field-level calculations, alerts and business
logic are facilitated by SuiteScripts which run within the user's browser as
they work with data and records within NetSuite. Additionally Server SuiteScript
APIs can be invoked via the Client SuiteScript code to apply business logic
beyond a single record.
2955 Campus Drive, Suite 250San Mateo, CA 650-627-1000gocheck - Rich testing for the Go language
Introduction
provides an internal testing
library, named testing, which is relatively slim due to the fact
that the standard library correctness by itself is verified using it.
The check package, on the other hand, expects the standard library
from Go to be working correctly, and builds on it to offer a richer
testing framework for libraries and applications to use.
gocheck includes features such as:
Helpful error reporting to aid on figuring problems out (see below)
Richer test helpers: assertions which interrupt the test immediately, deep multi-type comparisons, string matching, etc
Suite-based grouping of tests
Fixtures: per suite and/or per test set up and tear down
Benchmarks integrated in the suite logic (with fixtures, etc)
Management of temporary directories
Panic-catching logic, with proper error reporting
Proper counting of successes, failures, panics, missed tests, skips, etc
Explicit test skipping
Support for expected failures
Verbosity flag which disables output caching (helpful to debug hanging tests, for instance)
Multi-line string reporting for more comprehensible failures
Inclusion of comments surrounding checks on failure reports
Fully tested (it manages to test itself reliably)
Compatibility with "go test"
gocheck works as an extension to the testing package and
to the "go test" runner. That allows keeping all current tests
and using gocheck-based tests right away for new tests without conflicts.
The gocheck API was purposefully made similar to the testing
package for a smooth migration.
Installing and updating
Install gocheck's check package with the following command:
go get gopkg.in/check.v1
To ensure you're using the latest version, run the following instead:
go get -u gopkg.in/check.v1
API documentation
The API documentation for gocheck's check package is available online at:
Basic example
Here is a simple example of how to use gocheck.
package hello_test
. "gopkg.in/check.v1"
// Hook up gocheck into the "go test" runner.
func Test(t *testing.T) { TestingT(t) }
type MySuite struct{}
var _ = Suite(&MySuite{})
func (s *MySuite) TestHelloWorld(c *C) {
c.Assert(42, Equals, "42")
c.Assert(io.ErrClosedPipe, ErrorMatches, "io: .*on closed pipe")
c.Check(42, Equals, 42)
See Assertions and verifications below for more information on these tests.
Fixtures are available by using one or more of the following methods in a test suite:
func (s *SuiteType) SetUpSuite(c *C) - Run once when the suite starts running.
func (s *SuiteType) SetUpTest(c *C) - Run before each test or benchmark starts running.
func (s *SuiteType) TearDownTest(c *C) - Run after each test or benchmark runs.
func (s *SuiteType) TearDownSuite(c *C) - Run once after all tests or benchmarks have finished running.
Here is an example preparing some data in a temporary directory before each test runs:
type Suite struct{
dir string
func (s *MySuite) SetUpTest(c *C) {
s.dir = c.MkDir()
// Use s.dir to prepare some data.
func (s *MySuite) TestWithDir(c *C) {
// Use the data in s.dir in the test.
Benchmarks may be added by prefixing a method in the suite with Benchmark.
The method will be called with the usual *C argument, but unlike a
normal test it is supposed to put the benchmarked logic within a loop iterating
c.N times.
For example:
func (s *MySuite) BenchmarkLogic(c *C) {
for i := 0; i & c.N; i++ {
// Logic to benchmark
These methods are only run when in benchmark mode, using the -check.b
flag, and will present a result similar to the following when run:
PASS: myfile.go:67: MySuite.BenchmarkLogic
14026 ns/op
PASS: myfile.go:73: MySuite.BenchmarkOtherLogic
21133 ns/op
are run as usual for a test method.
To obtain the timing for normal tests, use the -check.v flag instead.
Skipping tests
Tests may be skipped with the
within SetUpSuite, SetUpTest, or the test method itself. This allows selectively ignoring
tests based on custom factors such as the architecture being run, flags provided to the
test, or the availbility of resources (network, etc).
As an example, the following test suite will skip all the tests within the suite
unless the -live option is provided to go test:
var live = flag.Bool("live", false, "Include live tests")
type LiveSuite struct{}
func (s *LiveSuite) SetUpSuite(c *C) {
if !*live {
c.Skip("-live not provided")
Running tests and output sample
Use the go test tool as usual to run the tests:
----------------------------------------------------------------------
FAIL: hello_test.go:16: S.TestHelloWorld
hello_test.go:17:
c.Check(42, Equals, "42")
... obtained int = 42
... expected string = "42"
hello_test.go:18:
c.Check(io.ErrClosedPipe, ErrorMatches, "BOOM")
... error string = "io: read/write on closed pipe"
... regex string = "BOOM"
OOPS: 0 passed, 1 FAILED
--- FAIL: hello_test.Test
Assertions and checks
gocheck uses two methods of *C to verify expectations on values
obtained in test cases:
these methods accept the same arguments, and the only difference between them
is that when Assert fails, the test is interrupted immediately, while
Check will fail the test, return false, and allow it to
continue for further checks.
Assert and Check have the following types:
func (c *C) Assert(obtained interface{}, chk Checker, ...args interface{})
func (c *C) Check(obtained interface{}, chk Checker, ...args interface{}) bool
They may be used as follows:
func (s *S) TestSimpleChecks(c *C) {
c.Assert(value, Equals, 42)
c.Assert(s, Matches, "hel.*there")
c.Assert(err, IsNil)
c.Assert(foo, Equals, bar, Commentf("#CPUs == %d", runtime.NumCPU())
The last statement will display the provided message next to the
usual debugging information, but only if the check fails.
Custom verifications may be defined by implementing the
interface.
are several standard checkers available.
See the documtation for details
and examples:
Selecting which tests to run
gocheck can filter tests out based on the test name, the suite name,
To run tests selectively, provide the command line option -check.f
when running go test.
Note that this option is specific to gocheck,
and won't affect go test itself.
Some examples:
$ go test -check.f MyTestSuite
$ go test -check.f "Test.*Works"
$ go test -check.f "MyTestSuite.Test.*Works"
Verbose modes
gocheck offers two levels of verbosity through the -check.v and -check.vv flags.
In the first mode, passing tests will also be reported.
The second mode will disable
log caching entirely and will stream starting and ending suite calls and everything
logged in between straight to the output.
This is useful to debug hanging tests, for
gocheck is made available under the .安全检查! | 百度云加速
请打开cookies。
为什么需要输入验证码?
输入验证码证明您不是机器人，输入后可以暂时浏览网站。
如何避免？
如果您使用私人电脑，可以下载杀毒软件，进行全盘扫描保证没有中毒。
如果您使用公用电脑，可以请网络管理员修正配置选项或查找病毒来源。